@NotNull
private DefaultMutableTreeNode addPackage(PsiPackage aPackage) {
final String qualifiedPackageName = aPackage.getQualifiedName();
final PsiPackage parentPackage = aPackage.getParentPackage();
if (parentPackage == null) {
final DefaultMutableTreeNode rootNode = (DefaultMutableTreeNode) myModel.getRoot();
if (qualifiedPackageName.length() == 0) {
rootNode.setUserObject(aPackage);
return rootNode;
} else {
DefaultMutableTreeNode packageNode = findPackageNode(rootNode, qualifiedPackageName);
if (packageNode != null) return packageNode;
packageNode = new DefaultMutableTreeNode(aPackage);
rootNode.add(packageNode);
return packageNode;
}
} else {
final DefaultMutableTreeNode parentNode = addPackage(parentPackage);
DefaultMutableTreeNode packageNode = findPackageNode(parentNode, qualifiedPackageName);
if (packageNode != null) {
return packageNode;
}
packageNode = new DefaultMutableTreeNode(aPackage);
parentNode.add(packageNode);
return packageNode;
}
}
protected void performRefactoring(
Project project,
PsiDirectory directory,
PsiPackage aPackage,
boolean searchInComments,
boolean searchForTextOccurences) {
final VirtualFile sourceRoot =
ProjectRootManager.getInstance(project)
.getFileIndex()
.getSourceRootForFile(directory.getVirtualFile());
if (sourceRoot == null) {
Messages.showErrorDialog(
project,
RefactoringBundle.message("destination.directory.does.not.correspond.to.any.package"),
RefactoringBundle.message("cannot.move"));
return;
}
final JavaRefactoringFactory factory = JavaRefactoringFactory.getInstance(project);
final MoveDestination destination =
myPreserveSourceRoot.isSelected() && myPreserveSourceRoot.isVisible()
? factory.createSourceFolderPreservingMoveDestination(aPackage.getQualifiedName())
: factory.createSourceRootMoveDestination(aPackage.getQualifiedName(), sourceRoot);
MoveClassesOrPackagesProcessor processor =
new MoveClassesOrPackagesProcessor(
myDirectory.getProject(),
myElementsToMove,
destination,
searchInComments,
searchForTextOccurences,
myMoveCallback);
if (processor.verifyValidPackageName()) {
processor.run();
}
}
@Nullable
protected String getContainerText(final PsiElement element, final String name) {
final PsiDirectory parent = ((PsiFile) element).getParent();
if (parent == null) return null;
final PsiPackage psiPackage = JavaDirectoryService.getInstance().getPackage(parent);
if (psiPackage == null) return null;
return "(" + psiPackage.getQualifiedName() + ")";
}
@Nullable
private static DefaultMutableTreeNode findPackageNode(
DefaultMutableTreeNode rootNode, String qualifiedName) {
for (int i = 0; i < rootNode.getChildCount(); i++) {
final DefaultMutableTreeNode child = (DefaultMutableTreeNode) rootNode.getChildAt(i);
final PsiPackage nodePackage = (PsiPackage) child.getUserObject();
if (nodePackage != null) {
if (Comparing.equal(nodePackage.getQualifiedName(), qualifiedName)) return child;
}
}
return null;
}
private DefaultMutableTreeNode findNodeForPackage(String qualifiedPackageName) {
DefaultMutableTreeNode root = (DefaultMutableTreeNode) myModel.getRoot();
Enumeration enumeration = root.depthFirstEnumeration();
while (enumeration.hasMoreElements()) {
Object o = enumeration.nextElement();
if (o instanceof DefaultMutableTreeNode) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode) o;
PsiPackage nodePackage = (PsiPackage) node.getUserObject();
if (nodePackage != null) {
if (Comparing.equal(nodePackage.getQualifiedName(), qualifiedPackageName)) return node;
}
}
}
return null;
}
private JUnitConfiguration createConfiguration(PsiPackage psiPackage, Module module) {
JUnitConfiguration configuration =
new JUnitConfiguration(
"", myProject, JUnitConfigurationType.getInstance().getConfigurationFactories()[0]);
configuration.getPersistentData().TEST_OBJECT = JUnitConfiguration.TEST_PACKAGE;
configuration.getPersistentData().PACKAGE_NAME = psiPackage.getQualifiedName();
configuration.getPersistentData().setScope(TestSearchScope.WHOLE_PROJECT);
configuration.setModule(module);
return configuration;
}
private static List<String> extractAllInPackageTests(
JavaParameters parameters, PsiPackage psiPackage) throws IOException {
String filePath =
ContainerUtil.find(
parameters.getProgramParametersList().getArray(),
value ->
StringUtil.startsWithChar(value, '@') && !StringUtil.startsWith(value, "@w@"))
.substring(1);
List<String> lines = readLinesFrom(new File(filePath));
assertEquals(psiPackage.getQualifiedName(), lines.get(0));
// lines.remove(0);
lines.remove(0);
return lines;
}
public void testAllInPackageForCommonAncestorModule() throws IOException, ExecutionException {
disposeModule(getModule2());
addModule("module5", true);
Module ancestor = getModule1();
Module child1 = getModule2();
Module child2 = getModule3();
addDependency(ancestor, child1);
addDependency(ancestor, child2);
PsiPackage psiPackage = JavaPsiFacade.getInstance(myProject).findPackage("test1");
JUnitConfiguration configuration =
createJUnitConfiguration(
psiPackage, AllInPackageConfigurationProducer.class, new MapDataContext());
configuration.getPersistentData().setScope(TestSearchScope.WHOLE_PROJECT);
assertNotNull(configuration);
checkPackage(psiPackage.getQualifiedName(), configuration);
assertEmpty(configuration.getModules());
JavaParameters parameters = checkCanRun(configuration);
List<String> tests = extractAllInPackageTests(parameters, psiPackage);
String childTest1 = findClass(child1, "test1.TestB").getQualifiedName();
String childTest2 = findClass(child2, "test1.Test5").getQualifiedName();
String ancestorTest = findClass(ancestor, "test1.TestA").getQualifiedName();
CHECK.containsAll(tests, new Object[] {ancestorTest, childTest1, childTest2});
}
@NotNull
private static PsiClass createBeanClass(final WizardData wizardData) throws MyException {
final PsiManager psiManager = PsiManager.getInstance(wizardData.myProject);
final ProjectRootManager projectRootManager =
ProjectRootManager.getInstance(wizardData.myProject);
final ProjectFileIndex fileIndex = projectRootManager.getFileIndex();
final VirtualFile sourceRoot = fileIndex.getSourceRootForFile(wizardData.myFormFile);
if (sourceRoot == null) {
throw new MyException(UIDesignerBundle.message("error.form.file.is.not.in.source.root"));
}
final PsiDirectory rootDirectory = psiManager.findDirectory(sourceRoot);
LOG.assertTrue(rootDirectory != null);
final PsiPackage aPackage =
JavaPsiFacade.getInstance(psiManager.getProject()).findPackage(wizardData.myPackageName);
if (aPackage == null) {
throw new MyException(
UIDesignerBundle.message("error.package.does.not.exist", wizardData.myPackageName));
}
PsiDirectory targetDir = null;
final PsiDirectory[] directories = aPackage.getDirectories();
for (final PsiDirectory psiDirectory : directories) {
if (PsiTreeUtil.isAncestor(rootDirectory, psiDirectory, false)) {
targetDir = psiDirectory;
break;
}
}
if (targetDir == null) {
// todo
throw new MyException(
UIDesignerBundle.message("error.cannot.find.package", wizardData.myPackageName));
}
//noinspection HardCodedStringLiteral
final String body =
"public class "
+ wizardData.myShortClassName
+ "{\n"
+ "public "
+ wizardData.myShortClassName
+ "(){}\n"
+ "}";
try {
PsiFile sourceFile =
PsiFileFactory.getInstance(psiManager.getProject())
.createFileFromText(wizardData.myShortClassName + ".java", body);
sourceFile = (PsiFile) targetDir.add(sourceFile);
final PsiClass beanClass = ((PsiJavaFile) sourceFile).getClasses()[0];
final ArrayList<String> properties = new ArrayList<String>();
final HashMap<String, String> property2fqClassName = new HashMap<String, String>();
final FormProperty2BeanProperty[] bindings = wizardData.myBindings;
for (final FormProperty2BeanProperty binding : bindings) {
if (binding == null || binding.myBeanProperty == null) {
continue;
}
properties.add(binding.myBeanProperty.myName);
// todo: handle "casts" ?
final String propertyClassName = binding.myFormProperty.getComponentPropertyClassName();
property2fqClassName.put(binding.myBeanProperty.myName, propertyClassName);
}
generateBean(beanClass, ArrayUtil.toStringArray(properties), property2fqClassName);
return beanClass;
} catch (IncorrectOperationException e) {
throw new MyException(e.getMessage());
}
}