com.qulice.checkstyle.MethodsOrderCheck Maven / Gradle / Ivy
The newest version!
/*
* Copyright (c) 2011-2024 Qulice.com
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met: 1) Redistributions of source code must retain the above
* copyright notice, this list of conditions and the following
* disclaimer. 2) Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution. 3) Neither the name of the Qulice.com nor
* the names of its contributors may be used to endorse or promote
* products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT
* NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.qulice.checkstyle;
import com.google.common.base.Optional;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import com.puppycrawl.tools.checkstyle.api.AbstractCheck;
import com.puppycrawl.tools.checkstyle.api.DetailAST;
import com.puppycrawl.tools.checkstyle.api.TokenTypes;
import java.util.List;
import java.util.Map;
/**
* Checks the order of methods declaration.
*
* Right order is: public, protected and private
* @since 0.6
*/
public final class MethodsOrderCheck extends AbstractCheck {
@Override
public int[] getDefaultTokens() {
return new int[]{
TokenTypes.CLASS_DEF,
TokenTypes.ENUM_DEF,
};
}
@Override
public int[] getAcceptableTokens() {
return this.getDefaultTokens();
}
@Override
public int[] getRequiredTokens() {
return this.getDefaultTokens();
}
@Override
public void visitToken(final DetailAST ast) {
if (ast.getType() == TokenTypes.CLASS_DEF
|| ast.getType() == TokenTypes.ENUM_DEF) {
this.checkClass(ast);
}
}
/**
* Checks class definition to satisfy the rule.
* @param node Tree node, containing class definition (CLASS_DEF).
*/
private void checkClass(final DetailAST node) {
final DetailAST obj = node.findFirstToken(TokenTypes.OBJBLOCK);
if (obj != null) {
this.checkOrder(
MethodsOrderCheck.findAllChildren(
obj, TokenTypes.METHOD_DEF
)
);
}
}
/**
* Checks order of methods.
*
* @param methods Nodes representing class methods
*/
private void checkOrder(final Iterable methods) {
MethodsOrderCheck.Modifiers prev = MethodsOrderCheck.Modifiers.PUB;
for (final DetailAST method : methods) {
final MethodsOrderCheck.Modifiers mtype =
MethodsOrderCheck.getModifierType(method);
if (mtype.getOrder() < prev.getOrder()) {
this.log(
method.getLineNo(),
"Wrong method declaration order"
);
} else {
prev = mtype;
}
}
}
/**
* Get method modifier as enum {@code Modifiers}.
* @param method DetailAST of method
* @return Element of {@code Modifiers} enum
*/
private static MethodsOrderCheck.Modifiers getModifierType(
final DetailAST method
) {
final DetailAST modifiers = method.findFirstToken(TokenTypes.MODIFIERS);
final DetailAST modifier = Optional.fromNullable(
modifiers.findFirstToken(
MethodsOrderCheck.Modifiers.PUB.getType()
)
).or(
Optional.fromNullable(
modifiers.findFirstToken(
MethodsOrderCheck.Modifiers.PROT.getType()
)
)
).or(
Optional.fromNullable(
modifiers.findFirstToken(
MethodsOrderCheck.Modifiers.PRIV.getType()
)
)
).orNull();
final MethodsOrderCheck.Modifiers mod;
if (modifier == null) {
mod = MethodsOrderCheck.Modifiers.DEF;
} else {
mod = getByType(modifier.getType());
}
return mod;
}
/**
* Search for all children of given type.
* @param base Parent node to start from
* @param type Node type
* @return Iterable
*/
private static Iterable findAllChildren(final DetailAST base,
final int type) {
final List children = Lists.newArrayList();
DetailAST child = base.getFirstChild();
while (child != null) {
if (child.getType() == type) {
children.add(child);
}
child = child.getNextSibling();
}
return children;
}
/**
* Get Modifiers enum constant by TokenType id.
* @param type TokenType
* @return Modifiers constant
*/
private static MethodsOrderCheck.Modifiers getByType(final int type) {
return MethodsOrderCheck.Modifiers.mdos.get(type);
}
/**
* Enumeration for constants of method modifiers.
*/
private enum Modifiers {
/**
* PUBLIC method modifier.
*/
PUB(TokenTypes.LITERAL_PUBLIC, 1),
/**
* PROTECTED method modifier.
*/
PROT(TokenTypes.LITERAL_PROTECTED, 2),
/**
* DEFAULT method modifier.
* No correspondent constant in TokenType.
*/
DEF(-1, 3),
/**
* PRIVATE method modifier.
*/
PRIV(TokenTypes.LITERAL_PRIVATE, 4);
/**
* Convenient map of {@code TokenType} on {@code Modifiers}.
*/
private static Map mdos;
static {
MethodsOrderCheck.Modifiers.mdos =
ImmutableMap.builder()
.put(PUB.getType(), PUB)
.put(PROT.getType(), PROT)
.put(-1, DEF)
.put(PRIV.getType(), PRIV)
.build();
}
/**
* TokenType.
*/
private final Integer type;
/**
* Order of modifier.
*/
private final int order;
/**
* Constructor.
* @param typ TokenType of DetailAST which represents modifier
* @param ord Order of the modifier in class definition
*/
Modifiers(final Integer typ, final Integer ord) {
this.type = typ;
this.order = ord;
}
/**
* TokenType.
* @return TokenType
*/
public int getType() {
return this.type;
}
/**
* Order of modifier.
* @return Order number
*/
public int getOrder() {
return this.order;
}
}
}