private static PsiDirectory getWritableModuleDirectory(
@NotNull Query<VirtualFile> vFiles, @NotNull Module module, PsiManager manager) {
for (VirtualFile vFile : vFiles) {
if (ModuleUtil.findModuleForFile(vFile, module.getProject()) != module) continue;
PsiDirectory directory = manager.findDirectory(vFile);
if (directory != null && directory.isValid() && directory.isWritable()) {
return directory;
}
}
return null;
}
public static boolean isAccessible(
final Project project, final VirtualFile virtualFile, final VirtualFile targetVirtualFile) {
final boolean inTestSourceContent =
ProjectRootManager.getInstance(project).getFileIndex().isInTestSourceContent(virtualFile);
final Module module = ModuleUtil.findModuleForFile(virtualFile, project);
if (targetVirtualFile != null
&& module != null
&& !GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module, inTestSourceContent)
.contains(targetVirtualFile)) {
return false;
}
return true;
}
@Override
protected void notifyByBalloon(
JUnitRunningModel model, boolean started, final JUnitConsoleProperties consoleProperties) {
if (myFoundTests) {
super.notifyByBalloon(model, started, consoleProperties);
} else {
final String packageName = myConfiguration.getPackage();
if (packageName == null) return;
final Project project = myConfiguration.getProject();
final PsiPackage aPackage = JavaPsiFacade.getInstance(project).findPackage(packageName);
if (aPackage == null) return;
final Module module = myConfiguration.getConfigurationModule().getModule();
if (module == null) return;
final Set<Module> modulesWithPackage = new HashSet<Module>();
final PsiDirectory[] directories = aPackage.getDirectories();
for (PsiDirectory directory : directories) {
final Module currentModule =
ModuleUtil.findModuleForFile(directory.getVirtualFile(), project);
if (module != currentModule && currentModule != null) {
modulesWithPackage.add(currentModule);
}
}
if (!modulesWithPackage.isEmpty()) {
final String testRunDebugId =
consoleProperties.isDebug() ? ToolWindowId.DEBUG : ToolWindowId.RUN;
final ToolWindowManager toolWindowManager = ToolWindowManager.getInstance(project);
final Function<Module, String> moduleNameRef =
new Function<Module, String>() {
@Override
public String fun(Module module) {
final String moduleName = module.getName();
return "<a href=\"" + moduleName + "\">" + moduleName + "</a>";
}
};
String message = "Tests were not found in module \"" + module.getName() + "\".\n" + "Use ";
if (modulesWithPackage.size() == 1) {
message += "module \"" + moduleNameRef.fun(modulesWithPackage.iterator().next()) + "\" ";
} else {
message += "one of\n" + StringUtil.join(modulesWithPackage, moduleNameRef, "\n") + "\n";
}
message += "instead";
toolWindowManager.notifyByBalloon(
testRunDebugId,
MessageType.WARNING,
message,
null,
new ResetConfigurationModuleAdapter(
project, consoleProperties, toolWindowManager, testRunDebugId));
}
}
}
/** @param rootContainer output parameter; should be LwRootContainer[1] */
public static FormProperty[] exposeForm(
final Project project, final VirtualFile formFile, final LwRootContainer[] rootContainer)
throws MyException {
final Module module = ModuleUtil.findModuleForFile(formFile, project);
LOG.assertTrue(module != null);
final PsiPropertiesProvider propertiesProvider = new PsiPropertiesProvider(module);
final Document doc = FileDocumentManager.getInstance().getDocument(formFile);
final LwRootContainer _rootContainer;
try {
_rootContainer = Utils.getRootContainer(doc.getText(), propertiesProvider);
} catch (AlienFormFileException e) {
throw new MyException(e.getMessage());
} catch (Exception e) {
throw new MyException(UIDesignerBundle.message("error.cannot.process.form.file", e));
}
rootContainer[0] = _rootContainer;
final String classToBind = _rootContainer.getClassToBind();
if (classToBind == null) {
throw new MyException(UIDesignerBundle.message("error.form.is.not.bound.to.a.class"));
}
final PsiClass boundClass = FormEditingUtil.findClassToBind(module, classToBind);
if (boundClass == null) {
throw new MyException(
UIDesignerBundle.message("error.bound.class.does.not.exist", classToBind));
}
final ArrayList<FormProperty> result = new ArrayList<FormProperty>();
final MyException[] exception = new MyException[1];
FormEditingUtil.iterate(
_rootContainer,
new FormEditingUtil.ComponentVisitor<LwComponent>() {
public boolean visit(final LwComponent component) {
final String binding = component.getBinding();
if (binding == null) {
return true;
}
final PsiField[] fields = boundClass.getFields();
PsiField field = null;
for (int i = fields.length - 1; i >= 0; i--) {
if (binding.equals(fields[i].getName())) {
field = fields[i];
break;
}
}
if (field == null) {
exception[0] =
new MyException(
UIDesignerBundle.message(
"error.field.not.found.in.class", binding, classToBind));
return false;
}
final PsiClass fieldClass = getClassByType(field.getType());
if (fieldClass == null) {
exception[0] =
new MyException(
UIDesignerBundle.message(
"error.invalid.binding.field.type", binding, classToBind));
return false;
}
if (instanceOf(fieldClass, JTextComponent.class.getName())) {
result.add(new FormProperty(component, "getText", "setText", String.class.getName()));
} else if (instanceOf(fieldClass, JCheckBox.class.getName())) {
result.add(
new FormProperty(
component, "isSelected", "setSelected", boolean.class.getName()));
}
return true;
}
});
if (exception[0] != null) {
throw exception[0];
}
return result.toArray(new FormProperty[result.size()]);
}
/** Should be invoked in command and write action */
@SuppressWarnings({"HardCodedStringLiteral"})
public static void generateDataBindingMethods(final WizardData data) throws MyException {
if (data.myBindToNewBean) {
data.myBeanClass = createBeanClass(data);
} else {
if (!CommonRefactoringUtil.checkReadOnlyStatus(
data.myBeanClass.getProject(), data.myBeanClass)) {
return;
}
}
final HashMap<String, String> binding2beanGetter = new HashMap<String, String>();
final HashMap<String, String> binding2beanSetter = new HashMap<String, String>();
final FormProperty2BeanProperty[] bindings = data.myBindings;
for (final FormProperty2BeanProperty form2bean : bindings) {
if (form2bean == null || form2bean.myBeanProperty == null) {
continue;
}
// check that bean contains the property, and if not, try to add the property to the bean
{
final String setterName = PropertyUtil.suggestSetterName(form2bean.myBeanProperty.myName);
final PsiMethod[] methodsByName = data.myBeanClass.findMethodsByName(setterName, true);
if (methodsByName.length < 1) {
// bean does not contain this property
// try to add...
LOG.assertTrue(
!data.myBindToNewBean); // just generated bean class should contain all necessary
// properties
if (!data.myBeanClass.isWritable()) {
throw new MyException(
"Cannot add property to non writable class " + data.myBeanClass.getQualifiedName());
}
final StringBuffer membersBuffer = new StringBuffer();
final StringBuffer methodsBuffer = new StringBuffer();
final Project project = data.myBeanClass.getProject();
final CodeStyleManager formatter = CodeStyleManager.getInstance(project);
final JavaCodeStyleManager styler = JavaCodeStyleManager.getInstance(project);
generateProperty(
styler,
form2bean.myBeanProperty.myName,
form2bean.myBeanProperty.myType,
membersBuffer,
methodsBuffer);
final PsiClass fakeClass;
try {
fakeClass =
JavaPsiFacade.getInstance(data.myBeanClass.getProject())
.getElementFactory()
.createClassFromText(membersBuffer.toString() + methodsBuffer.toString(), null);
final PsiField[] fields = fakeClass.getFields();
{
final PsiElement result = data.myBeanClass.add(fields[0]);
styler.shortenClassReferences(result);
formatter.reformat(result);
}
final PsiMethod[] methods = fakeClass.getMethods();
{
final PsiElement result = data.myBeanClass.add(methods[0]);
styler.shortenClassReferences(result);
formatter.reformat(result);
}
{
final PsiElement result = data.myBeanClass.add(methods[1]);
styler.shortenClassReferences(result);
formatter.reformat(result);
}
} catch (IncorrectOperationException e) {
throw new MyException(e.getMessage());
}
}
}
final PsiMethod propertySetter =
PropertyUtil.findPropertySetter(
data.myBeanClass, form2bean.myBeanProperty.myName, false, true);
final PsiMethod propertyGetter =
PropertyUtil.findPropertyGetter(
data.myBeanClass, form2bean.myBeanProperty.myName, false, true);
if (propertyGetter == null) {
// todo
continue;
}
if (propertySetter == null) {
// todo
continue;
}
final String binding = form2bean.myFormProperty.getLwComponent().getBinding();
binding2beanGetter.put(binding, propertyGetter.getName());
binding2beanSetter.put(binding, propertySetter.getName());
}
final String dataBeanClassName = data.myBeanClass.getQualifiedName();
final LwRootContainer[] rootContainer = new LwRootContainer[1];
final FormProperty[] formProperties =
exposeForm(data.myProject, data.myFormFile, rootContainer);
final StringBuffer getDataBody = new StringBuffer();
final StringBuffer setDataBody = new StringBuffer();
final StringBuffer isModifiedBody = new StringBuffer();
// iterate exposed formproperties
for (final FormProperty formProperty : formProperties) {
final String binding = formProperty.getLwComponent().getBinding();
if (!binding2beanGetter.containsKey(binding)) {
continue;
}
getDataBody.append("data.");
getDataBody.append(binding2beanSetter.get(binding));
getDataBody.append("(");
getDataBody.append(binding);
getDataBody.append(".");
getDataBody.append(formProperty.getComponentPropertyGetterName());
getDataBody.append("());\n");
setDataBody.append(binding);
setDataBody.append(".");
setDataBody.append(formProperty.getComponentPropertySetterName());
setDataBody.append("(data.");
setDataBody.append(binding2beanGetter.get(binding));
setDataBody.append("());\n");
final String propertyClassName = formProperty.getComponentPropertyClassName();
if ("boolean".equals(propertyClassName)) {
isModifiedBody.append("if (");
//
isModifiedBody.append(binding);
isModifiedBody.append(".");
isModifiedBody.append(formProperty.getComponentPropertyGetterName());
isModifiedBody.append("()");
//
isModifiedBody.append("!= ");
//
isModifiedBody.append("data.");
isModifiedBody.append(binding2beanGetter.get(binding));
isModifiedBody.append("()");
//
isModifiedBody.append(") return true;\n");
} else {
isModifiedBody.append("if (");
//
isModifiedBody.append(binding);
isModifiedBody.append(".");
isModifiedBody.append(formProperty.getComponentPropertyGetterName());
isModifiedBody.append("()");
//
isModifiedBody.append("!= null ? ");
//
isModifiedBody.append("!");
//
isModifiedBody.append(binding);
isModifiedBody.append(".");
isModifiedBody.append(formProperty.getComponentPropertyGetterName());
isModifiedBody.append("()");
//
isModifiedBody.append(".equals(");
//
isModifiedBody.append("data.");
isModifiedBody.append(binding2beanGetter.get(binding));
isModifiedBody.append("()");
isModifiedBody.append(") : ");
//
isModifiedBody.append("data.");
isModifiedBody.append(binding2beanGetter.get(binding));
isModifiedBody.append("()");
isModifiedBody.append("!= null");
//
isModifiedBody.append(") return true;\n");
}
}
isModifiedBody.append("return false;\n");
final String textOfMethods =
"public void setData("
+ dataBeanClassName
+ " data){\n"
+ setDataBody.toString()
+ "}\n"
+ "\n"
+ "public void getData("
+ dataBeanClassName
+ " data){\n"
+ getDataBody.toString()
+ "}\n"
+ "\n"
+ "public boolean isModified("
+ dataBeanClassName
+ " data){\n"
+ isModifiedBody.toString()
+ "}\n";
// put them to the bound class
final Module module = ModuleUtil.findModuleForFile(data.myFormFile, data.myProject);
LOG.assertTrue(module != null);
final PsiClass boundClass =
FormEditingUtil.findClassToBind(module, rootContainer[0].getClassToBind());
LOG.assertTrue(boundClass != null);
if (!CommonRefactoringUtil.checkReadOnlyStatus(module.getProject(), boundClass)) {
return;
}
// todo: check that this method does not exist yet
final PsiClass fakeClass;
try {
fakeClass =
JavaPsiFacade.getInstance(data.myProject)
.getElementFactory()
.createClassFromText(textOfMethods, null);
final PsiMethod methodSetData = fakeClass.getMethods()[0];
final PsiMethod methodGetData = fakeClass.getMethods()[1];
final PsiMethod methodIsModified = fakeClass.getMethods()[2];
final PsiMethod existing1 = boundClass.findMethodBySignature(methodSetData, false);
final PsiMethod existing2 = boundClass.findMethodBySignature(methodGetData, false);
final PsiMethod existing3 = boundClass.findMethodBySignature(methodIsModified, false);
// warning already shown
if (existing1 != null) {
existing1.delete();
}
if (existing2 != null) {
existing2.delete();
}
if (existing3 != null) {
existing3.delete();
}
final CodeStyleManager formatter = CodeStyleManager.getInstance(module.getProject());
final JavaCodeStyleManager styler = JavaCodeStyleManager.getInstance(module.getProject());
final PsiElement setData = boundClass.add(methodSetData);
styler.shortenClassReferences(setData);
formatter.reformat(setData);
final PsiElement getData = boundClass.add(methodGetData);
styler.shortenClassReferences(getData);
formatter.reformat(getData);
if (data.myGenerateIsModified) {
final PsiElement isModified = boundClass.add(methodIsModified);
styler.shortenClassReferences(isModified);
formatter.reformat(isModified);
}
final OpenFileDescriptor descriptor =
new OpenFileDescriptor(
setData.getProject(),
setData.getContainingFile().getVirtualFile(),
setData.getTextOffset());
FileEditorManager.getInstance(data.myProject).openTextEditor(descriptor, true);
} catch (IncorrectOperationException e) {
throw new MyException(e.getMessage());
}
}
/**
* Here we check if a given file belongs to our plugin. We take this road because we need the
* actual file and not a filename to check files without extension.
*
* <p>A file is checked according to the rules defined in the facet settings. A file can be set to
* ignored, accepted or auto. Auto means that the content is checked.
*
* @param file The file to check
* @return True if BashSupport wants to take that file
*/
public boolean isMyFileType(VirtualFile file) {
if (file == null) {
return false;
}
if (file.isDirectory()) {
return false;
}
if (extensionList.contains(file.getExtension())) {
return true;
} else if (!file.isInLocalFileSystem()) {
return false;
} else if (StringUtils.isEmpty(file.getExtension())) {
BashFacet facet = null;
try {
// no extensions, special checks (looking at the content, etc)
// guess project
Project project = ProjectUtil.guessProjectForFile(file);
if (project == null) {
return false;
}
DumbServiceImpl dumbService = DumbServiceImpl.getInstance(project);
if (dumbService == null || dumbService.isDumb()) {
return false;
}
DirectoryIndex directoryIndex = DirectoryIndex.getInstance(project);
if (directoryIndex == null || !directoryIndex.isInitialized()) {
return false;
}
Module module = ModuleUtil.findModuleForFile(file, project);
if (module == null) {
return false;
}
facet = BashFacet.getInstance(module);
if (facet == null) {
return false;
}
BashFacetConfiguration config = facet.getConfiguration();
FileMode mode = config.findMode(file);
if (mode == FileMode.accept()) {
return true;
} else if (mode == FileMode.ignore()) {
return false;
} else if (mode == FileMode.auto()) {
return BashContentUtil.isProbablyBashFile(
VfsUtil.virtualToIoFile(file),
MIN_FILE_PROBABILIY,
ProjectUtil.guessProjectForFile(file));
}
} catch (Exception e) {
// ignore this
LOG.warn("Could not check the file type due to exception", e);
}
}
return false;
}
public static Module getCurrentModule() {
final Component owner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
VirtualFile file =
PlatformDataKeys.VIRTUAL_FILE.getData(DataManager.getInstance().getDataContext(owner));
return ModuleUtil.findModuleForFile(file, getCurrentProject());
}
