public PostprocessReformattingAspect(
Project project, PsiManager psiManager, TreeAspect treeAspect) {
myProject = project;
myPsiManager = psiManager;
myTreeAspect = treeAspect;
PomManager.getModel(psiManager.getProject())
.registerAspect(
PostprocessReformattingAspect.class,
this,
Collections.singleton((PomModelAspect) treeAspect));
ApplicationListener applicationListener =
new ApplicationAdapter() {
public void writeActionStarted(final Object action) {
final CommandProcessor processor = CommandProcessor.getInstance();
if (processor != null) {
final Project project = processor.getCurrentCommandProject();
if (project == myProject) {
myPostponedCounter++;
}
}
}
public void writeActionFinished(final Object action) {
final CommandProcessor processor = CommandProcessor.getInstance();
if (processor != null) {
final Project project = processor.getCurrentCommandProject();
if (project == myProject) {
decrementPostponedCounter();
}
}
}
};
ApplicationManager.getApplication().addApplicationListener(applicationListener, this);
}
@NotNull
private Collection<PsiFileSystemItem> getContextByFile(@NotNull PsiFile file) {
final PsiElement context = file.getContext();
if (context != null) file = context.getContainingFile();
if (useIncludingFileAsContext()) {
final FileContextProvider contextProvider = FileContextProvider.getProvider(file);
if (contextProvider != null) {
final Collection<PsiFileSystemItem> folders = contextProvider.getContextFolders(file);
if (!folders.isEmpty()) {
return folders;
}
final PsiFile contextFile = contextProvider.getContextFile(file);
if (contextFile != null) {
return Collections.<PsiFileSystemItem>singleton(contextFile.getParent());
}
}
}
VirtualFile virtualFile = file.getOriginalFile().getVirtualFile();
if (virtualFile != null) {
final FileReferenceHelper[] helpers = FileReferenceHelperRegistrar.getHelpers();
final ArrayList<PsiFileSystemItem> list = new ArrayList<PsiFileSystemItem>();
final Project project = file.getProject();
for (FileReferenceHelper helper : helpers) {
if (helper.isMine(project, virtualFile)) {
list.addAll(helper.getContexts(project, virtualFile));
}
}
if (list.size() > 0) {
return list;
}
final VirtualFile parent = virtualFile.getParent();
if (parent != null) {
final PsiDirectory directory = file.getManager().findDirectory(parent);
if (directory != null) {
return Collections.<PsiFileSystemItem>singleton(directory);
}
}
}
return Collections.emptyList();
}
public static void invokeOnScope(
final Project project, final PsiMember member, final AnalysisScope scope) {
invokeOnScope(project, Collections.singleton(member), scope, false);
}
public static boolean hasTest(
PsiModifierListOwner element,
boolean checkHierarchy,
boolean checkDisabled,
boolean checkJavadoc) {
// LanguageLevel effectiveLanguageLevel = element.getManager().getEffectiveLanguageLevel();
// boolean is15 = effectiveLanguageLevel != LanguageLevel.JDK_1_4 && effectiveLanguageLevel !=
// LanguageLevel.JDK_1_3;
boolean hasAnnotation =
AnnotationUtil.isAnnotated(element, TEST_ANNOTATION_FQN, checkHierarchy, true);
if (hasAnnotation) {
if (checkDisabled) {
PsiAnnotation annotation =
AnnotationUtil.findAnnotation(element, true, TEST_ANNOTATION_FQN);
if (annotation != null) {
if (isDisabled(annotation)) return false;
}
}
return true;
}
if (element instanceof PsiDocCommentOwner
&& checkJavadoc
&& getTextJavaDoc((PsiDocCommentOwner) element) != null) return true;
// now we check all methods for the test annotation
if (element instanceof PsiClass) {
PsiClass psiClass = (PsiClass) element;
for (PsiMethod method : psiClass.getAllMethods()) {
PsiAnnotation annotation = AnnotationUtil.findAnnotation(method, true, TEST_ANNOTATION_FQN);
if (annotation != null) {
if (checkDisabled) {
if (isDisabled(annotation)) continue;
}
return true;
}
if (AnnotationUtil.isAnnotated(method, FACTORY_ANNOTATION_FQN, false, true)) return true;
if (checkJavadoc && getTextJavaDoc(method) != null) return true;
}
return false;
} else if (element instanceof PsiMethod) {
// even if it has a global test, we ignore private and static methods
if (element.hasModifierProperty(PsiModifier.PRIVATE)
|| element.hasModifierProperty(PsiModifier.STATIC)) {
return false;
}
// if it's a method, we check if the class it's in has a global @Test annotation
PsiClass psiClass = ((PsiMethod) element).getContainingClass();
if (psiClass != null) {
final PsiAnnotation annotation =
checkHierarchy
? AnnotationUtil.findAnnotationInHierarchy(
psiClass, Collections.singleton(TEST_ANNOTATION_FQN))
: AnnotationUtil.findAnnotation(psiClass, true, TEST_ANNOTATION_FQN);
if (annotation != null) {
if (checkDisabled && isDisabled(annotation)) return false;
return !hasConfig(element);
} else if (checkJavadoc && getTextJavaDoc(psiClass) != null) return true;
}
}
return false;
}
