org.sonar.plugins.java.api.tree.AnnotationTree Java Examples

protected boolean checkIfLongSession(MethodTree method) {
    List<AnnotationTree> annotations = method.modifiers().annotations();
    for (AnnotationTree annotationTree : annotations) {
        if (annotationTree.annotationType().is(Tree.Kind.IDENTIFIER)) {
            IdentifierTree idf = (IdentifierTree) annotationTree.annotationType();
            if (idf.name().equals(ACTIVATE)) {
                collectLongSessionOpened(method);
                return true;
            } else if (idf.name().equals(DEACTIVATE)) {
                collectLongSessionClosed(method);
                return true;
            }
        }
    }
    return false;
}
 

protected boolean checkIfLongResourceResolver(MethodTree method) {
    List<AnnotationTree> annotations = method.modifiers().annotations();
    for (AnnotationTree annotationTree : annotations) {
        if (annotationTree.annotationType().is(Tree.Kind.IDENTIFIER)) {
            IdentifierTree idf = (IdentifierTree) annotationTree.annotationType();
            if (idf.name().equals(ACTIVATE)) {
                collectLongResourceResolverOpened(method);
                return true;
            } else if (idf.name().equals(DEACTIVATE)) {
                collectLongResourceResolverClosed(method);
                return true;
            }
        }
    }
    return false;
}
 

@Override
public void visitClass(ClassTree tree) {
    List<AnnotationTree> annotationTrees = getAnnotationTrees(tree);

    if (annotationTrees.isEmpty() || !annotationsContainAnnotationWhichIsPartOfTestPackage(annotationTrees)) {
        super.visitClass(tree);
    }
}
 

@Override
public void visitAnnotation(AnnotationTree annotationTree) {
    if (isSearchedAnnotation(annotationTree, OPTIONAL_ANNOTATION_FULL_NAME)) {
        context.reportIssue(scanner, annotationTree, RULE_MESSAGE);
    }
    super.visitAnnotation(annotationTree);
}
 

@Override
public void visitClass(ClassTree tree) {
    List<AnnotationTree> annotations = tree.modifiers().annotations();
    for (AnnotationTree annotationTree : annotations) {
        if (isSearchedAnnotation(annotationTree, MODEL_ANNOTATION_FULL_NAME)
            && isOptionalDefaultValue(annotationTree.arguments())) {
            CheckIfOptionalAnnotationIsPresent checkIfOptionalIsPresent = new CheckIfOptionalAnnotationIsPresent(
                this);
            tree.accept(checkIfOptionalIsPresent);
        }
    }
    super.visitClass(tree);
}
 

void checkAnnotationLocators(AnnotationTree tree, LocatorStrategyCheckType locatorStrategyCheckType) {
    Map<String, String> locatorsInAnnotationTree = getLocatorValueMapInAnnotationTree(tree);

    for (Map.Entry<String, String> locator : locatorsInAnnotationTree.entrySet()) {
        checkLocator(tree, locator.getKey(), locator.getValue(), locatorStrategyCheckType);
    }
}
 

public static boolean annotationsContainAnnotationWhichIsPartOfTestPackage(List<AnnotationTree> annotationTrees) {
    boolean annotationIsPartOfTestPackage = false;

    for (AnnotationTree annotationTree : annotationTrees) {
        if (annotationIsPartOfTestPackage(annotationTree)) {
            annotationIsPartOfTestPackage = true;
        }
    }

    return annotationIsPartOfTestPackage;
}
 

public static Map<String, String> getLocatorValueMapInAnnotationTree(AnnotationTree annotationTree) {
    Map<String, String> locatorMap = new HashMap<>();
    String annotationType = annotationTree.annotationType().toString();
    String fullyQualifiedName = annotationTree.annotationType().symbolType().fullyQualifiedName();

    if (FIND_BY_ANNOTATION_NAME.equals(annotationType) &&
        isPartOfWebDriverPackage(fullyQualifiedName)) {
        for (ExpressionTree expressionTree : annotationTree.arguments()) {
            AssignmentExpressionTree assignmentExpressionTree = (AssignmentExpressionTree) expressionTree;

            String property = assignmentExpressionTree.variable().toString();
            String locator = HOW_PROPERTY.equals(property)
                ? ((MemberSelectExpressionTree) ((AssignmentExpressionTree) expressionTree)
                .expression()).identifier().name()
                : ((AssignmentExpressionTree) expressionTree).variable().toString();

            String propertyValue = assignmentExpressionTree.expression().is(Kind.STRING_LITERAL)
                ? ((LiteralTree) assignmentExpressionTree.expression()).value().replace("\"", "")
                : null;

            ExpressionTree howExpressionTree = annotationTree.arguments()
                .stream()
                .filter(aet -> HOW_PROPERTY.equals(((AssignmentExpressionTree) aet).variable().toString()))
                // Only one "how" property allowed in annotation
                .findFirst()
                .orElse(null);

            if (howExpressionTree != null && USING_PROPERTY.equals(property)) {
                String howLocator = ((MemberSelectExpressionTree) ((AssignmentExpressionTree) howExpressionTree)
                    .expression()).identifier().name();
                locatorMap.put(howLocator, propertyValue);
            } else {
                locatorMap.put(locator, propertyValue);
            }
        }
    }

    return locatorMap;
}
 

public static List<AnnotationTree> getAnnotationTrees(ClassTree tree) {
    List<AnnotationTree> annotationTrees = new ArrayList<>();
    List<Tree> members = tree.members();

    for (Tree member : members) {
        if (METHOD_KIND.equals(member.kind().toString())) {
            annotationTrees.addAll(((MethodTree) member).modifiers().annotations());
        }
    }

    return annotationTrees;
}
 

@Override
public void visitClass(ClassTree tree) {
    List<AnnotationTree> annotationTrees = getAnnotationTrees(tree);

    if (annotationsContainAnnotationWhichIsPartOfTestPackage(annotationTrees)) {
        super.visitClass(tree);
    }
}
 

@Override
public void visitAnnotation(AnnotationTree annotationTree) {
    if (annotations.hasSlingServletAnnotation() && isPropertyAnnotation(annotationTree)) {
        for (ExpressionTree expression : annotationTree.arguments()) {
            if (isAssignmentToName(expression)) {
                checkIfPropertyInsteadSlingServletIsUsed(annotationTree, (AssignmentExpressionTree) expression);
            }
        }
    }
    super.visitAnnotation(annotationTree);
}
 

@Override
public void visitAnnotation(AnnotationTree annotationTree) {
    standardComponentAnnotation |= isOfType(annotationTree, "org.osgi.service.component.annotations.Component");
    legacyServiceAnnotation |= isOfType(annotationTree, "org.apache.felix.scr.annotations.Service");
    legacyComponentAnnotation |= isOfType(annotationTree, "org.apache.felix.scr.annotations.Component");
    slingServletAnnotation |= isOfType(annotationTree, "org.apache.felix.scr.annotations.sling.SlingServlet");
    super.visitAnnotation(annotationTree);
}
 

@Override
public void visitNode(final Tree tree) {
    final AnnotationTree annotationTree = (AnnotationTree) tree;
    final Type symbolType = annotationTree.annotationType()
        .symbolType();
    if (symbolType.is("com.qualinsight.plugins.sonarqube.smell.api.annotation.Smell")) {
        handleSmellAnnotation(annotationTree);
    }
}
 

private void handleSmellAnnotation(final AnnotationTree annotationTree) {
    String message = "";
    Integer minutes = 0;
    SmellType type = null;
    final Arguments arguments = annotationTree.arguments();
    for (final ExpressionTree expressionTree : arguments) {
        if (expressionTree.is(Tree.Kind.ASSIGNMENT)) {
            final AssignmentExpressionTree aet = (AssignmentExpressionTree) expressionTree;
            final String variable = ((IdentifierTree) aet.variable()).name();
            switch (variable) {
                case "minutes":
                    minutes += Integer.valueOf(((LiteralTree) aet.expression()).value());
                    LOGGER.debug("{} = {}", variable, minutes);
                    break;
                case "reason":
                    message = extractMessage(aet.expression());
                    LOGGER.debug("{} = {}", variable, message);
                    break;
                case "type":
                    type = SmellType.valueOf(((MemberSelectExpressionTree) aet.expression()).identifier()
                        .name());
                    break;
                default:
                    break;
            }
        }
    }
    if (smellType().equals(type)) {
        final Matcher matcher = PATTERN.matcher(message);
        if (matcher.matches()) {
            message = matcher.group(1);
        }
        reportIssue(annotationTree, message, new ArrayList<JavaFileScannerContext.Location>(), minutes);
    }
}
 

private static boolean annotationIsPartOfTestPackage(AnnotationTree annotationTree) {
    String annotation = annotationTree.annotationType().toString();
    String fullyQualifiedName = annotationTree.annotationType().symbolType().fullyQualifiedName();

    return TEST_ANNOTATION_NAMES.contains(annotation) && isPartOfTestPackage(fullyQualifiedName);
}
 

private boolean isPropertyAnnotation(AnnotationTree annotationTree) {
    return isOfType(annotationTree, "org.apache.felix.scr.annotations.Property");
}
 

private boolean isOfType(AnnotationTree annotationTree, String fullyQualifiedName) {
    return annotationTree.annotationType().symbolType().fullyQualifiedName().equals(fullyQualifiedName);
}
 

private boolean isSearchedAnnotation(AnnotationTree annotationTree, String fullyQualifiedName) {
    return annotationTree.annotationType().symbolType().fullyQualifiedName().equals(fullyQualifiedName);
}
 

@Override
public void visitAnnotation(AnnotationTree annotationTree) {
    inAnnotation = true;
    super.visitAnnotation(annotationTree);
    inAnnotation = false;
}
 

@Override
public void visitAnnotation(AnnotationTree tree) {
    checkAnnotationLocators(tree, XPATH_LOCATOR_STRATEGY);
}
 

@Override
public void visitAnnotation(AnnotationTree tree) {
    checkAnnotationLocators(tree, ID_VALUE);
}
 

@Override
public void visitAnnotation(AnnotationTree tree) {
    checkAnnotationLocators(tree, CSS_VALUE);
}
 

@Override
public void visitAnnotation(AnnotationTree tree) {
    checkAnnotationLocators(tree, LINK_TEXT_AND_TAG_NAME_LOCATOR_STRATEGY);
}
 

@Override
public void visitAnnotation(AnnotationTree tree) {
    checkAnnotationLocators(tree, XPATH_VALUE);
}
 

@Override
public void visitAnnotation(AnnotationTree tree) {
    checkAnnotationLocators(tree, CLASS_NAME_VALUE);
}