| /******************************************************************************* |
| * Copyright (c) 2000, 2017 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| *******************************************************************************/ |
| package org.eclipse.dltk.internal.corext.refactoring.reorg; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.eclipse.core.filebuffers.FileBuffers; |
| import org.eclipse.core.filebuffers.ITextFileBuffer; |
| import org.eclipse.core.filebuffers.LocationKind; |
| import org.eclipse.core.resources.IContainer; |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IFolder; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.IResourceVisitor; |
| import org.eclipse.core.resources.mapping.IResourceChangeDescriptionFactory; |
| import org.eclipse.core.runtime.Assert; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.OperationCanceledException; |
| import org.eclipse.dltk.core.DLTKCore; |
| import org.eclipse.dltk.core.DLTKFeatures; |
| import org.eclipse.dltk.core.DLTKLanguageManager; |
| import org.eclipse.dltk.core.IDLTKLanguageToolkit; |
| import org.eclipse.dltk.core.IModelElement; |
| import org.eclipse.dltk.core.IProjectFragment; |
| import org.eclipse.dltk.core.IScriptFolder; |
| import org.eclipse.dltk.core.IScriptProject; |
| import org.eclipse.dltk.core.ISourceModule; |
| import org.eclipse.dltk.core.IType; |
| import org.eclipse.dltk.core.ModelException; |
| import org.eclipse.dltk.internal.corext.refactoring.RefactoringAvailabilityTester; |
| import org.eclipse.dltk.internal.corext.refactoring.RefactoringCoreMessages; |
| import org.eclipse.dltk.internal.corext.refactoring.participants.ResourceProcessors; |
| import org.eclipse.dltk.internal.corext.refactoring.participants.ScriptProcessors; |
| import org.eclipse.dltk.internal.corext.refactoring.tagging.ICommentProvider; |
| import org.eclipse.dltk.internal.corext.refactoring.util.ModelElementUtil; |
| import org.eclipse.dltk.internal.corext.refactoring.util.ResourceUtil; |
| import org.eclipse.dltk.internal.corext.refactoring.util.TextChangeManager; |
| import org.eclipse.dltk.internal.corext.util.Messages; |
| import org.eclipse.dltk.internal.corext.util.Resources; |
| import org.eclipse.dltk.ui.DLTKUIPlugin; |
| import org.eclipse.ltk.core.refactoring.Change; |
| import org.eclipse.ltk.core.refactoring.RefactoringStatus; |
| import org.eclipse.ltk.core.refactoring.participants.CheckConditionsContext; |
| import org.eclipse.ltk.core.refactoring.participants.DeleteProcessor; |
| import org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant; |
| import org.eclipse.ltk.core.refactoring.participants.ResourceChangeChecker; |
| import org.eclipse.ltk.core.refactoring.participants.SharableParticipants; |
| |
| public final class ScriptDeleteProcessor extends DeleteProcessor |
| implements ICommentProvider { |
| |
| private boolean fWasCanceled; |
| private Object[] fElements; |
| private IResource[] fResources; |
| private IModelElement[] fScriptElements; |
| private IReorgQueries fDeleteQueries; |
| private DeleteModifications fDeleteModifications; |
| private String fComment; |
| |
| private Change fDeleteChange; |
| private boolean fDeleteSubPackages; |
| |
| public static final String IDENTIFIER = "org.eclipse.dltk.ui.DeleteProcessor"; //$NON-NLS-1$ |
| |
| public ScriptDeleteProcessor(Object[] elements) { |
| fElements = elements; |
| fResources = RefactoringAvailabilityTester.getResources(elements); |
| fScriptElements = RefactoringAvailabilityTester |
| .getScriptElements(elements); |
| fDeleteSubPackages = false; |
| fWasCanceled = false; |
| } |
| |
| // ---- IRefactoringProcessor |
| // --------------------------------------------------- |
| |
| @Override |
| public String getIdentifier() { |
| return IDENTIFIER; |
| } |
| |
| @Override |
| public boolean isApplicable() throws CoreException { |
| if (fElements.length == 0) |
| return false; |
| if (fElements.length != fResources.length + fScriptElements.length) |
| return false; |
| for (int i = 0; i < fResources.length; i++) { |
| if (!RefactoringAvailabilityTester.isDeleteAvailable(fResources[i])) |
| return false; |
| } |
| for (int i = 0; i < fScriptElements.length; i++) { |
| if (!RefactoringAvailabilityTester |
| .isDeleteAvailable(fScriptElements[i])) |
| return false; |
| } |
| return true; |
| } |
| |
| public boolean needsProgressMonitor() { |
| if (fResources != null && fResources.length > 0) |
| return true; |
| if (fScriptElements != null) { |
| for (int i = 0; i < fScriptElements.length; i++) { |
| int type = fScriptElements[i].getElementType(); |
| if (type <= IModelElement.SOURCE_MODULE) |
| return true; |
| } |
| } |
| return false; |
| |
| } |
| |
| @Override |
| public String getProcessorName() { |
| return RefactoringCoreMessages.DeleteRefactoring_7; |
| } |
| |
| @Override |
| public Object[] getElements() { |
| return fElements; |
| } |
| |
| @Override |
| public RefactoringParticipant[] loadParticipants(RefactoringStatus status, |
| SharableParticipants shared) throws CoreException { |
| return fDeleteModifications.loadParticipants(status, this, |
| getAffectedProjectNatures(), shared); |
| } |
| |
| private String[] getAffectedProjectNatures() throws CoreException { |
| String[] jNatures = ScriptProcessors |
| .computeAffectedNaturs(fScriptElements); |
| String[] rNatures = ResourceProcessors |
| .computeAffectedNatures(fResources); |
| Set<String> result = new HashSet<>(); |
| result.addAll(Arrays.asList(jNatures)); |
| result.addAll(Arrays.asList(rNatures)); |
| return result.toArray(new String[result.size()]); |
| } |
| |
| public void setDeleteSubPackages(boolean selection) { |
| fDeleteSubPackages = selection; |
| } |
| |
| public boolean getDeleteSubPackages() { |
| return fDeleteSubPackages; |
| } |
| |
| public boolean hasSubPackagesToDelete() { |
| try { |
| for (int i = 0; i < fScriptElements.length; i++) { |
| if (fScriptElements[i] instanceof IScriptFolder) { |
| IScriptFolder scriptFolder = (IScriptFolder) fScriptElements[i]; |
| if (scriptFolder.isRootFolder()) |
| continue; // see bug 132576 (can remove this if(..) |
| // continue; statement when bug is fixed) |
| if (scriptFolder.hasSubfolders()) |
| return true; |
| } |
| } |
| } catch (ModelException e) { |
| DLTKUIPlugin.log(e); |
| } |
| return false; |
| } |
| |
| public void setQueries(IReorgQueries queries) { |
| Assert.isNotNull(queries); |
| fDeleteQueries = queries; |
| } |
| |
| public IModelElement[] getScriptElementsToDelete() { |
| return fScriptElements; |
| } |
| |
| public boolean wasCanceled() { |
| return fWasCanceled; |
| } |
| |
| public IResource[] getResourcesToDelete() { |
| return fResources; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.dltk.internal.corext.refactoring.base.Refactoring# |
| * checkActivation(org.eclipse.core.runtime.IProgressMonitor) |
| */ |
| @Override |
| public RefactoringStatus checkInitialConditions(IProgressMonitor pm) |
| throws CoreException { |
| Assert.isNotNull(fDeleteQueries);// must be set before checking |
| // activation |
| RefactoringStatus result = new RefactoringStatus(); |
| result.merge(RefactoringStatus.create( |
| Resources.checkInSync(ReorgUtils.getNotLinked(fResources)))); |
| IResource[] javaResources = ReorgUtils.getResources(fScriptElements); |
| result.merge(RefactoringStatus.create( |
| Resources.checkInSync(ReorgUtils.getNotLinked(javaResources)))); |
| for (int i = 0; i < fScriptElements.length; i++) { |
| // IModelElement element= fScriptElements[i]; |
| // if (element instanceof IType && ((IType)element).isAnonymous()) { |
| // // work around for bug |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=44450 |
| // // result.addFatalError("Currently, there isn't any support to |
| // delete an anonymous type."); |
| // } |
| } |
| return result; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.dltk.internal.corext.refactoring.base.Refactoring#checkInput( |
| * org.eclipse.core.runtime.IProgressMonitor) |
| */ |
| @Override |
| public RefactoringStatus checkFinalConditions(IProgressMonitor pm, |
| CheckConditionsContext context) throws CoreException { |
| pm.beginTask(RefactoringCoreMessages.DeleteRefactoring_1, 1); |
| try { |
| fWasCanceled = false; |
| RefactoringStatus result = new RefactoringStatus(); |
| |
| recalculateElementsToDelete(); |
| |
| TextChangeManager manager = new TextChangeManager(); |
| fDeleteChange = DeleteChangeCreator.createDeleteChange(manager, |
| fResources, fScriptElements, getProcessorName()); |
| checkDirtySourceModules(result); |
| checkDirtyResources(result); |
| fDeleteModifications = new DeleteModifications(); |
| fDeleteModifications.delete(fResources); |
| fDeleteModifications.delete(fScriptElements); |
| fDeleteModifications.postProcess(); |
| |
| ResourceChangeChecker checker = context |
| .getChecker(ResourceChangeChecker.class); |
| IResourceChangeDescriptionFactory deltaFactory = checker |
| .getDeltaFactory(); |
| fDeleteModifications.buildDelta(deltaFactory); |
| IFile[] files = getBuildpathFiles(); |
| for (int i = 0; i < files.length; i++) { |
| deltaFactory.change(files[i]); |
| } |
| files = ResourceUtil.getFiles(manager.getAllSourceModules()); |
| for (int i = 0; i < files.length; i++) { |
| deltaFactory.change(files[i]); |
| } |
| return result; |
| } catch (OperationCanceledException e) { |
| fWasCanceled = true; |
| throw e; |
| } catch (ModelException e) { |
| throw e; |
| } catch (CoreException e) { |
| throw new ModelException(e); |
| } finally { |
| pm.done(); |
| } |
| } |
| |
| private void checkDirtySourceModules(RefactoringStatus result) |
| throws CoreException { |
| if (fScriptElements == null || fScriptElements.length == 0) |
| return; |
| for (int je = 0; je < fScriptElements.length; je++) { |
| IModelElement element = fScriptElements[je]; |
| if (element instanceof ISourceModule) { |
| checkDirtySourceModule(result, (ISourceModule) element); |
| } else if (element instanceof IScriptFolder) { |
| ISourceModule[] units = ((IScriptFolder) element) |
| .getSourceModules(); |
| for (int u = 0; u < units.length; u++) { |
| checkDirtySourceModule(result, units[u]); |
| } |
| } |
| } |
| } |
| |
| private void checkDirtySourceModule(RefactoringStatus result, |
| ISourceModule cunit) { |
| IResource resource = cunit.getResource(); |
| if (resource == null || resource.getType() != IResource.FILE) |
| return; |
| checkDirtyFile(result, (IFile) resource); |
| } |
| |
| private void checkDirtyResources(final RefactoringStatus result) |
| throws CoreException { |
| for (int i = 0; i < fResources.length; i++) { |
| IResource resource = fResources[i]; |
| resource.accept((IResourceVisitor) visitedResource -> { |
| if (visitedResource instanceof IFile) { |
| checkDirtyFile(result, (IFile) visitedResource); |
| } |
| return true; |
| }, IResource.DEPTH_INFINITE, false); |
| } |
| } |
| |
| private void checkDirtyFile(RefactoringStatus result, IFile file) { |
| if (file == null || !file.exists()) |
| return; |
| ITextFileBuffer buffer = FileBuffers.getTextFileBufferManager() |
| .getTextFileBuffer(file.getFullPath(), LocationKind.NORMALIZE); |
| if (buffer != null && buffer.isDirty()) { |
| if (buffer.isStateValidated() && buffer.isSynchronized()) { |
| result.addWarning(Messages.format( |
| RefactoringCoreMessages.ScriptDeleteProcessor_unsaved_changes, |
| file.getFullPath().toString())); |
| } else { |
| result.addFatalError(Messages.format( |
| RefactoringCoreMessages.ScriptDeleteProcessor_unsaved_changes, |
| file.getFullPath().toString())); |
| } |
| } |
| } |
| |
| /* |
| * The set of elements that will eventually be deleted may be very different |
| * from the set originally selected - there may be fewer, more or different |
| * elements. This method is used to calculate the set of elements that will |
| * be deleted - if necessary, it asks the user. |
| */ |
| private void recalculateElementsToDelete() throws CoreException { |
| // the sequence is critical here |
| |
| if (fDeleteSubPackages) /* |
| * add subpackages first, to allow removing |
| * elements with parents in selection etc. |
| */ |
| addSubPackages(); |
| |
| removeElementsWithParentsInSelection(); /* |
| * ask before adding empty cus - |
| * you don't want to ask if you, |
| * for example delete the |
| * package, in which the cus |
| * live |
| */ |
| removeUnconfirmedFoldersThatContainSourceFolders(); /* |
| * a selected folder |
| * may be a parent |
| * of a source |
| * folder we must |
| * inform the user |
| * about it and ask |
| * if ok to delete |
| * the folder |
| */ |
| removeUnconfirmedReferencedArchives(); |
| addEmptySourceModulesToDelete(); |
| removeScriptElementsChildrenOfScriptElements();/* |
| * because adding cus |
| * may create elements |
| * (types in cus) whose |
| * parents are in |
| * selection |
| */ |
| confirmDeletingReadOnly(); /* |
| * after empty cus - you want to ask for all |
| * cus that are to be deleted |
| */ |
| |
| addDeletableParentPackagesOnPackageDeletion(); /* |
| * do not change the |
| * sequence in |
| * fScriptElements after |
| * this method |
| */ |
| } |
| |
| /** |
| * Adds all subpackages of the selected packages to the list of items to be |
| * deleted. |
| * |
| * @throws ModelException |
| */ |
| private void addSubPackages() throws ModelException { |
| |
| final Set<IModelElement> modelElements = new HashSet<>(); |
| for (int i = 0; i < fScriptElements.length; i++) { |
| if (fScriptElements[i] instanceof IScriptFolder) { |
| modelElements.addAll( |
| Arrays.asList(ModelElementUtil.getPackageAndSubpackages( |
| (IScriptFolder) fScriptElements[i]))); |
| } else { |
| modelElements.add(fScriptElements[i]); |
| } |
| } |
| |
| fScriptElements = modelElements |
| .toArray(new IModelElement[modelElements.size()]); |
| } |
| |
| /** |
| * Add deletable parent packages to the list of items to delete. |
| * |
| * @throws CoreException |
| */ |
| private void addDeletableParentPackagesOnPackageDeletion() |
| throws CoreException { |
| |
| final List/* <IScriptFolder */ initialPackagesToDelete = ReorgUtils |
| .getElementsOfType(fScriptElements, |
| IModelElement.SCRIPT_FOLDER); |
| |
| if (initialPackagesToDelete.size() == 0) |
| return; |
| |
| // Move from inner to outer packages |
| Collections.sort(initialPackagesToDelete, (arg0, arg1) -> { |
| IScriptFolder one = (IScriptFolder) arg0; |
| IScriptFolder two = (IScriptFolder) arg1; |
| return two.getElementName().compareTo(one.getElementName()); |
| }); |
| |
| // Get resources andscriptelements which will be deleted as well |
| final Set/* <IResource> */ deletedChildren = new HashSet(); |
| deletedChildren.addAll(Arrays.asList(fResources)); |
| for (int i = 0; i < fScriptElements.length; i++) { |
| if (!ReorgUtils.isInsideSourceModule(fScriptElements[i])) |
| deletedChildren.add(fScriptElements[i].getResource()); |
| } |
| |
| // new package list in the right sequence |
| final List<IScriptFolder> allFragmentsToDelete = new ArrayList<>(); |
| |
| for (Iterator outerIter = initialPackagesToDelete.iterator(); outerIter |
| .hasNext();) { |
| final IScriptFolder currentScriptFolder = (IScriptFolder) outerIter |
| .next(); |
| |
| // The package will at least be cleared |
| allFragmentsToDelete.add(currentScriptFolder); |
| |
| if (canRemoveCompletely(currentScriptFolder, |
| initialPackagesToDelete)) { |
| |
| final IScriptFolder parent = ModelElementUtil |
| .getParentSubpackage(currentScriptFolder); |
| if (parent != null |
| && !initialPackagesToDelete.contains(parent)) { |
| |
| final List/* <IScriptFolder> */ emptyParents = new ArrayList(); |
| addDeletableParentPackages(parent, initialPackagesToDelete, |
| deletedChildren, emptyParents); |
| |
| // Add parents in the right sequence (inner to outer) |
| allFragmentsToDelete.addAll(emptyParents); |
| } |
| } |
| } |
| |
| // Remove resources in deleted packages; and the packages as well |
| final List<IModelElement> modelElements = new ArrayList<>(); |
| for (int i = 0; i < fScriptElements.length; i++) { |
| if (!(fScriptElements[i] instanceof IScriptFolder)) { |
| // remove children of deleted packages |
| final IScriptFolder frag = (IScriptFolder) fScriptElements[i] |
| .getAncestor(IModelElement.SCRIPT_FOLDER); |
| if (!allFragmentsToDelete.contains(frag)) |
| modelElements.add(fScriptElements[i]); |
| } |
| } |
| // Re-add deleted packages - note the (new) sequence |
| modelElements.addAll(allFragmentsToDelete); |
| |
| // Remove resources in deleted folders |
| final List<IResource> resources = new ArrayList<>(); |
| for (int i = 0; i < fResources.length; i++) { |
| IResource parent = fResources[i]; |
| if (parent.getType() == IResource.FILE) |
| parent = parent.getParent(); |
| if (!deletedChildren.contains(parent)) |
| resources.add(fResources[i]); |
| } |
| |
| fScriptElements = modelElements |
| .toArray(new IModelElement[modelElements.size()]); |
| fResources = resources.toArray(new IResource[resources.size()]); |
| } |
| |
| /** |
| * Returns true if this initially selected package is really deletable (if |
| * it has non-selected subpackages, it may only be cleared). |
| * |
| */ |
| private boolean canRemoveCompletely(IScriptFolder pack, |
| List packagesToDelete) throws ModelException { |
| final IScriptFolder[] subPackages = ModelElementUtil |
| .getPackageAndSubpackages(pack); |
| for (int i = 0; i < subPackages.length; i++) { |
| if (!(subPackages[i].equals(pack)) |
| && !(packagesToDelete.contains(subPackages[i]))) |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * Adds deletable parent packages of the fragment "frag" to the list |
| * "deletableParentPackages"; also adds the resources of those packages to |
| * the set "resourcesToDelete". |
| * |
| */ |
| private void addDeletableParentPackages(IScriptFolder frag, |
| List initialPackagesToDelete, Set resourcesToDelete, |
| List deletableParentPackages) throws CoreException { |
| |
| if (frag.getResource().isLinked()) { |
| final IConfirmQuery query = fDeleteQueries.createYesNoQuery( |
| RefactoringCoreMessages.ScriptDeleteProcessor_confirm_linked_folder_delete, |
| false, IReorgQueries.CONFIRM_DELETE_LINKED_PARENT); |
| if (!query.confirm(Messages.format( |
| RefactoringCoreMessages.ScriptDeleteProcessor_delete_linked_folder_question, |
| new String[] { frag.getResource().getName() }))) |
| return; |
| } |
| |
| final IResource[] children = (((IContainer) frag.getResource())) |
| .members(); |
| for (int i = 0; i < children.length; i++) { |
| // Child must be a package fragment already in the list, |
| // or a resource which is deleted as well. |
| if (!resourcesToDelete.contains(children[i])) |
| return; |
| } |
| resourcesToDelete.add(frag.getResource()); |
| deletableParentPackages.add(frag); |
| |
| final IScriptFolder parent = ModelElementUtil.getParentSubpackage(frag); |
| if (parent != null && !initialPackagesToDelete.contains(parent)) |
| addDeletableParentPackages(parent, initialPackagesToDelete, |
| resourcesToDelete, deletableParentPackages); |
| } |
| |
| // ask for confirmation of deletion of all package fragment roots that are |
| // on buildpaths of other projects |
| private void removeUnconfirmedReferencedArchives() throws ModelException { |
| String queryTitle = RefactoringCoreMessages.DeleteRefactoring_2; |
| IConfirmQuery query = fDeleteQueries.createYesYesToAllNoNoToAllQuery( |
| queryTitle, true, |
| IReorgQueries.CONFIRM_DELETE_REFERENCED_ARCHIVES); |
| removeUnconfirmedReferencedProjectFragments(query); |
| removeUnconfirmedReferencedArchiveFiles(query); |
| } |
| |
| private void removeUnconfirmedReferencedArchiveFiles(IConfirmQuery query) |
| throws ModelException, OperationCanceledException { |
| List<IFile> filesToSkip = new ArrayList<>(0); |
| for (int i = 0; i < fResources.length; i++) { |
| IResource resource = fResources[i]; |
| if (!(resource instanceof IFile)) |
| continue; |
| |
| IScriptProject project = DLTKCore.create(resource.getProject()); |
| if (project == null || !project.exists()) |
| continue; |
| IProjectFragment root = project |
| .findProjectFragment(resource.getFullPath()); |
| if (root == null) |
| continue; |
| List referencingProjects = new ArrayList(1); |
| referencingProjects.add(root.getScriptProject()); |
| referencingProjects.addAll(Arrays |
| .asList(ModelElementUtil.getReferencingProjects(root))); |
| if (skipDeletingReferencedRoot(query, root, referencingProjects)) |
| filesToSkip.add((IFile) resource); |
| } |
| removeFromSetToDelete( |
| filesToSkip.toArray(new IFile[filesToSkip.size()])); |
| } |
| |
| private void removeUnconfirmedReferencedProjectFragments( |
| IConfirmQuery query) |
| throws ModelException, OperationCanceledException { |
| List<IModelElement> rootsToSkip = new ArrayList<>(0); |
| for (int i = 0; i < fScriptElements.length; i++) { |
| IModelElement element = fScriptElements[i]; |
| if (!(element instanceof IProjectFragment)) |
| continue; |
| IProjectFragment root = (IProjectFragment) element; |
| List referencingProjects = Arrays |
| .asList(ModelElementUtil.getReferencingProjects(root)); |
| if (skipDeletingReferencedRoot(query, root, referencingProjects)) |
| rootsToSkip.add(root); |
| } |
| removeFromSetToDelete( |
| rootsToSkip.toArray(new IModelElement[rootsToSkip.size()])); |
| } |
| |
| private static boolean skipDeletingReferencedRoot(IConfirmQuery query, |
| IProjectFragment root, List referencingProjects) |
| throws OperationCanceledException { |
| if (referencingProjects.isEmpty() || root == null || !root.exists() |
| || !root.isArchive()) |
| return false; |
| String question = Messages.format( |
| RefactoringCoreMessages.DeleteRefactoring_3, |
| root.getElementName()); |
| return !query.confirm(question, referencingProjects.toArray()); |
| } |
| |
| private void removeUnconfirmedFoldersThatContainSourceFolders() |
| throws CoreException { |
| String queryTitle = RefactoringCoreMessages.DeleteRefactoring_4; |
| IConfirmQuery query = fDeleteQueries.createYesYesToAllNoNoToAllQuery( |
| queryTitle, true, |
| IReorgQueries.CONFIRM_DELETE_FOLDERS_CONTAINING_SOURCE_FOLDERS); |
| List<IResource> foldersToSkip = new ArrayList<>(0); |
| for (int i = 0; i < fResources.length; i++) { |
| IResource resource = fResources[i]; |
| if (resource instanceof IFolder) { |
| IFolder folder = (IFolder) resource; |
| if (containsSourceFolder(folder)) { |
| String question = Messages.format( |
| RefactoringCoreMessages.DeleteRefactoring_5, |
| folder.getName()); |
| if (!query.confirm(question)) |
| foldersToSkip.add(folder); |
| } |
| } |
| } |
| removeFromSetToDelete( |
| foldersToSkip.toArray(new IResource[foldersToSkip.size()])); |
| } |
| |
| private static boolean containsSourceFolder(IFolder folder) |
| throws CoreException { |
| IResource[] subFolders = folder.members(); |
| for (int i = 0; i < subFolders.length; i++) { |
| if (!(subFolders[i] instanceof IFolder)) |
| continue; |
| IModelElement element = DLTKCore.create(folder); |
| if (element instanceof IProjectFragment) |
| return true; |
| if (element instanceof IScriptFolder) |
| continue; |
| if (containsSourceFolder((IFolder) subFolders[i])) |
| return true; |
| } |
| return false; |
| } |
| |
| private void removeElementsWithParentsInSelection() { |
| ParentChecker parentUtil = new ParentChecker(fResources, |
| fScriptElements); |
| parentUtil.removeElementsWithAncestorsOnList(false); |
| fScriptElements = parentUtil.getScriptElements(); |
| fResources = parentUtil.getResources(); |
| } |
| |
| private void removeScriptElementsChildrenOfScriptElements() { |
| ParentChecker parentUtil = new ParentChecker(fResources, |
| fScriptElements); |
| parentUtil.removeElementsWithAncestorsOnList(true); |
| fScriptElements = parentUtil.getScriptElements(); |
| } |
| |
| private IFile[] getBuildpathFiles() { |
| List result = new ArrayList(); |
| for (int i = 0; i < fScriptElements.length; i++) { |
| IModelElement element = fScriptElements[i]; |
| if (element instanceof IProjectFragment) { |
| IProject project = element.getScriptProject().getProject(); |
| IFile buildpathFile = project.getFile(".classpath"); //$NON-NLS-1$ |
| if (buildpathFile.exists()) |
| result.add(buildpathFile); |
| } |
| } |
| return (IFile[]) result.toArray(new IFile[result.size()]); |
| } |
| |
| @Override |
| public Change createChange(IProgressMonitor pm) throws CoreException { |
| pm.beginTask("", 1); //$NON-NLS-1$ |
| pm.done(); |
| return fDeleteChange; |
| } |
| |
| private void addToSetToDelete(IModelElement[] newElements) { |
| fScriptElements = ReorgUtils.union(fScriptElements, newElements); |
| } |
| |
| private void removeFromSetToDelete(IResource[] resourcesToNotDelete) { |
| fResources = ReorgUtils.setMinus(fResources, resourcesToNotDelete); |
| } |
| |
| private void removeFromSetToDelete(IModelElement[] elementsToNotDelete) { |
| fScriptElements = ReorgUtils.setMinus(fScriptElements, |
| elementsToNotDelete); |
| } |
| |
| // private static IField[] getFields(IModelElement[] elements){ |
| // List fields= new ArrayList(3); |
| // for (int i= 0; i < elements.length; i++) { |
| // if (elements[i] instanceof IField) |
| // fields.add(elements[i]); |
| // } |
| // return (IField[]) fields.toArray(new IField[fields.size()]); |
| // } |
| |
| // ----------- read-only confirmation business ------ |
| private void confirmDeletingReadOnly() throws CoreException { |
| if (!ReadOnlyResourceFinder.confirmDeleteOfReadOnlyElements( |
| fScriptElements, fResources, fDeleteQueries)) |
| throw new OperationCanceledException(); // saying 'no' to this one |
| // is like cancelling the |
| // whole operation |
| } |
| |
| // ----------- empty source modules related method |
| private void addEmptySourceModulesToDelete() throws ModelException { |
| Set<ISourceModule> modulesToEmpty = getCusToEmpty(); |
| addToSetToDelete(modulesToEmpty |
| .toArray(new ISourceModule[modulesToEmpty.size()])); |
| } |
| |
| private Set<ISourceModule> getCusToEmpty() throws ModelException { |
| Set<ISourceModule> result = new HashSet<>(); |
| for (int i = 0; i < fScriptElements.length; i++) { |
| IModelElement element = fScriptElements[i]; |
| ISourceModule module = ReorgUtils.getSourceModule(element); |
| if (module != null && !result.contains(module)) { |
| IDLTKLanguageToolkit toolkit = DLTKLanguageManager |
| .getLanguageToolkit(module); |
| if (toolkit != null && toolkit |
| .get(DLTKFeatures.DELETE_MODULE_WITHOUT_TOP_LEVEL_TYPES) |
| && willHaveAllTopLevelTypesDeleted(module)) { |
| result.add(module); |
| } |
| } |
| } |
| return result; |
| } |
| |
| private boolean willHaveAllTopLevelTypesDeleted(ISourceModule cu) |
| throws ModelException { |
| Set elementSet = new HashSet(Arrays.asList(fScriptElements)); |
| IType[] topLevelTypes = cu.getTypes(); |
| for (int i = 0; i < topLevelTypes.length; i++) { |
| if (!elementSet.contains(topLevelTypes[i])) |
| return false; |
| } |
| return true; |
| } |
| |
| @Override |
| public boolean canEnableComment() { |
| return true; |
| } |
| |
| @Override |
| public String getComment() { |
| return fComment; |
| } |
| |
| @Override |
| public void setComment(String comment) { |
| fComment = comment; |
| } |
| } |
