| /******************************************************************************* |
| * Copyright (c) 2000, 2009 IBM Corporation and others. |
| * |
| * This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License 2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| * Brock Janiczak <brockj@tpg.com.au> - Bug 161536 Warn user when committing resources with problem markers |
| * Brock Janiczak <brockj@tpg.com.au> - Bug 177519 [Wizards] Adopt new IResource.findMaxProblemSeverity API |
| * Brock Janiczak <brockj@tpg.com.au> - Bug 166333 [Wizards] Show diff in CVS commit dialog |
| * |
| *******************************************************************************/ |
| package org.eclipse.team.internal.ccvs.ui.wizards; |
| |
| import java.lang.reflect.InvocationTargetException; |
| import java.util.*; |
| |
| import org.eclipse.core.resources.*; |
| import org.eclipse.core.resources.mapping.ResourceMapping; |
| import org.eclipse.core.resources.mapping.ResourceTraversal; |
| import org.eclipse.core.runtime.*; |
| import org.eclipse.core.runtime.jobs.*; |
| import org.eclipse.jface.dialogs.*; |
| import org.eclipse.jface.preference.IPreferenceStore; |
| import org.eclipse.jface.wizard.IWizardPage; |
| import org.eclipse.jface.wizard.WizardDialog; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.team.core.IFileContentManager; |
| import org.eclipse.team.core.Team; |
| import org.eclipse.team.core.diff.*; |
| import org.eclipse.team.core.mapping.*; |
| import org.eclipse.team.core.synchronize.SyncInfoSet; |
| import org.eclipse.team.internal.ccvs.core.*; |
| import org.eclipse.team.internal.ccvs.core.client.Command; |
| import org.eclipse.team.internal.ccvs.core.resources.CVSWorkspaceRoot; |
| import org.eclipse.team.internal.ccvs.ui.*; |
| import org.eclipse.team.internal.ccvs.ui.actions.CommitAction; |
| import org.eclipse.team.internal.ccvs.ui.mappings.AbstractCommitAction; |
| import org.eclipse.team.internal.ccvs.ui.mappings.WorkspaceSubscriberContext; |
| import org.eclipse.team.internal.ccvs.ui.operations.*; |
| import org.eclipse.team.internal.core.subscribers.SubscriberDiffTreeEventHandler; |
| import org.eclipse.team.internal.ui.Policy; |
| import org.eclipse.team.internal.ui.Utils; |
| import org.eclipse.team.ui.synchronize.ModelSynchronizeParticipant; |
| import org.eclipse.ui.IWorkbenchPart; |
| import org.eclipse.ui.PlatformUI; |
| |
| /** |
| * A wizard to commit the resources whose synchronization state is given in form |
| * of a set of <code>SyncInfo</code>. |
| */ |
| public class CommitWizard extends ResizableWizard { |
| |
| public static final String COMMIT_WIZARD_DIALOG_SETTINGS = "CommitWizard"; //$NON-NLS-1$ |
| |
| /** |
| * An operation to add and commit resources to a CVS repository. |
| */ |
| public static class AddAndCommitOperation extends CVSOperation { |
| |
| private final IResource[] fAllResources; |
| private final String fComment; |
| |
| private Map fModesForExtensionsForOneTime; |
| private Map fModesForNamesForOneTime; |
| |
| private IResource[] fNewResources; |
| private IJobChangeListener jobListener; |
| |
| public AddAndCommitOperation(IWorkbenchPart part, IResource[] allResources, IResource[] newResources, String comment) { |
| super(part); |
| fAllResources = allResources; |
| fNewResources = newResources; |
| fModesForExtensionsForOneTime = Collections.EMPTY_MAP; |
| fModesForNamesForOneTime= Collections.EMPTY_MAP; |
| fComment = comment; |
| } |
| |
| public void setModesForExtensionsForOneTime(Map modes) { |
| if (modes != null) |
| fModesForExtensionsForOneTime= modes; |
| } |
| |
| public void setModesForNamesForOneTime(Map modes) { |
| if (modes != null) |
| fModesForNamesForOneTime= modes; |
| } |
| |
| @Override |
| protected void execute(IProgressMonitor monitor) throws CVSException, InterruptedException { |
| try { |
| monitor.beginTask(null, (fNewResources.length + fAllResources.length) * 100); |
| if (fNewResources.length > 0) { |
| final AddOperation op= new AddOperation(getPart(), RepositoryProviderOperation.asResourceMappers(fNewResources)); |
| op.addModesForExtensions(fModesForExtensionsForOneTime); |
| op.addModesForNames(fModesForNamesForOneTime); |
| op.run(Policy.subMonitorFor(monitor, fNewResources.length * 100)); |
| } |
| if (fAllResources.length > 0) { |
| CommitOperation commitOperation = new CommitOperation(getPart(), RepositoryProviderOperation.asResourceMappers(fAllResources), new Command.LocalOption[0], fComment) { |
| @Override |
| public boolean consultModelsForMappings() { |
| // Do not consult models from the commit wizard |
| return false; |
| } |
| }; |
| commitOperation.run(Policy.subMonitorFor(monitor, fAllResources.length * 100)); |
| } |
| } catch (InvocationTargetException e) { |
| throw CVSException.wrapException(e); |
| } finally { |
| monitor.done(); |
| } |
| } |
| |
| @Override |
| protected String getJobName() { |
| return CVSUIMessages.CommitWizard_0; |
| } |
| |
| @Override |
| protected String getTaskName() { |
| return CVSUIMessages.CommitWizard_1; |
| } |
| |
| /* |
| * Set the job listener. It will only recieve scheduled and done |
| * events as these are what are used by a sync model operation |
| * to show busy state in the sync view. |
| */ |
| protected void setJobChangeListener(IJobChangeListener jobListener) { |
| this.jobListener = jobListener; |
| } |
| |
| @Override |
| public void done(IJobChangeEvent event) { |
| super.done(event); |
| if (jobListener != null) |
| jobListener.done(event); |
| } |
| |
| @Override |
| public void scheduled(IJobChangeEvent event) { |
| super.scheduled(event); |
| if (jobListener != null) |
| jobListener.scheduled(event); |
| } |
| } |
| |
| private final IResource[] fResources; |
| private IResource[] fUnaddedDiffs; |
| private final ModelSynchronizeParticipant fParticipant; |
| |
| private CommitWizardFileTypePage fFileTypePage; |
| private CommitWizardCommitPage fCommitPage; |
| private IJobChangeListener jobListener; |
| private IWorkbenchPart part; |
| |
| public CommitWizard(SyncInfoSet infos) throws CVSException { |
| this(infos.getResources()); |
| } |
| |
| public CommitWizard(final IResource [] resources) throws CVSException { |
| |
| super(COMMIT_WIZARD_DIALOG_SETTINGS, CVSUIPlugin.getPlugin().getDialogSettings()); |
| |
| setNeedsProgressMonitor(true); |
| setWindowTitle(CVSUIMessages.CommitWizard_2); |
| setDefaultPageImageDescriptor(CVSUIPlugin.getPlugin().getImageDescriptor(ICVSUIConstants.IMG_WIZBAN_NEW_LOCATION)); |
| |
| fResources= resources; |
| ResourceMapping[] mappings = Utils.getResourceMappings(resources); |
| fParticipant = createWorkspaceParticipant(mappings, getShell()); |
| |
| getAllOutOfSync(); |
| fUnaddedDiffs = getUnaddedResources(getDiffTree().getAffectedResources()); |
| } |
| |
| private ModelSynchronizeParticipant createWorkspaceParticipant(ResourceMapping[] selectedMappings, Shell shell) { |
| ISynchronizationScopeManager manager = WorkspaceSubscriberContext.createWorkspaceScopeManager(selectedMappings, true, CommitAction.isIncludeChangeSets(shell, CVSUIMessages.SyncAction_1)); |
| return new CommitWizardParticipant(WorkspaceSubscriberContext.createContext(manager, ISynchronizationContext.THREE_WAY), this); |
| } |
| |
| public CommitWizard(SyncInfoSet infos, IJobChangeListener jobListener) throws CVSException { |
| this(infos); |
| this.jobListener = jobListener; |
| } |
| |
| private void getAllOutOfSync() throws CVSException { |
| try { |
| ISynchronizationContext context = getParticipant().getContext(); |
| SubscriberDiffTreeEventHandler handler = Adapters.adapt(context, SubscriberDiffTreeEventHandler.class); |
| handler.initializeIfNeeded(); |
| Job.getJobManager().join(context, null); |
| } catch (InterruptedException e) { |
| throw new OperationCanceledException(); |
| } |
| } |
| |
| public boolean hasOutgoingChanges() { |
| IResourceDiffTree tree = getDiffTree(); |
| return tree != null && tree.hasMatchingDiffs(ResourcesPlugin.getWorkspace().getRoot().getFullPath(), new FastDiffFilter() { |
| @Override |
| public boolean select(IDiff diff) { |
| return AbstractCommitAction.hasLocalChange(diff); |
| } |
| }); |
| } |
| |
| boolean hasConflicts() { |
| IResourceDiffTree tree = getDiffTree(); |
| return tree != null && tree.hasMatchingDiffs(ResourcesPlugin.getWorkspace().getRoot().getFullPath(), new FastDiffFilter() { |
| @Override |
| public boolean select(IDiff diff) { |
| if (diff instanceof IThreeWayDiff) { |
| IThreeWayDiff twd = (IThreeWayDiff) diff; |
| return twd.getDirection() == IThreeWayDiff.CONFLICTING; |
| } |
| return false; |
| } |
| }); |
| } |
| |
| public int getHighestProblemSeverity() { |
| IResource[] resources = getDiffTree().getAffectedResources(); |
| int mostSeriousSeverity = -1; |
| |
| for (int i = 0; i < resources.length; i++) { |
| IResource resource = resources[i]; |
| try { |
| int severity = resource.findMaxProblemSeverity(IMarker.PROBLEM, true, IResource.DEPTH_ZERO); |
| if (severity > mostSeriousSeverity) { |
| mostSeriousSeverity = severity; |
| } |
| } catch (CoreException e) { |
| } |
| } |
| |
| return mostSeriousSeverity; |
| } |
| |
| IResourceDiffTree getDiffTree() { |
| return fParticipant.getContext().getDiffTree(); |
| } |
| |
| public CommitWizardFileTypePage getFileTypePage() { |
| return fFileTypePage; |
| } |
| |
| public CommitWizardCommitPage getCommitPage() { |
| return fCommitPage; |
| } |
| |
| public ModelSynchronizeParticipant getParticipant() { |
| return fParticipant; |
| } |
| |
| @Override |
| public boolean canFinish() { |
| final IWizardPage current= getContainer().getCurrentPage(); |
| if (current == fFileTypePage && fCommitPage != null) |
| return false; |
| return super.canFinish(); |
| } |
| |
| @Override |
| public boolean performFinish() { |
| |
| final String comment= fCommitPage.getComment(getShell()); |
| if (comment == null) |
| return false; |
| |
| IResource[] resources = AbstractCommitAction.getOutgoingChanges(getDiffTree(), fCommitPage.getTraversalsToCommit(), null); |
| if (resources.length == 0) |
| return true; |
| |
| final IResource[] unadded; |
| try { |
| unadded = getUnaddedResources(resources); |
| } catch (CVSException e1) { |
| return false; |
| } |
| |
| final IResource[] files = getFiles(resources); |
| |
| final AddAndCommitOperation operation= new AddAndCommitOperation(getPart(), files, unadded, comment); |
| if (jobListener != null) |
| operation.setJobChangeListener(jobListener); |
| |
| if (fFileTypePage != null) { |
| final Map extensionsToSave= new HashMap(); |
| final Map extensionsNotToSave= new HashMap(); |
| |
| fFileTypePage.getModesForExtensions(extensionsToSave, extensionsNotToSave); |
| CommitWizardFileTypePage.saveExtensionMappings(extensionsToSave); |
| operation.setModesForExtensionsForOneTime(extensionsNotToSave); |
| |
| final Map namesToSave= new HashMap(); |
| final Map namesNotToSave= new HashMap(); |
| |
| fFileTypePage.getModesForNames(namesToSave, namesNotToSave); |
| CommitWizardFileTypePage.saveNameMappings(namesToSave); |
| operation.setModesForNamesForOneTime(namesNotToSave); |
| } |
| |
| try { |
| operation.run(); |
| } catch (InvocationTargetException e) { |
| return false; |
| } catch (InterruptedException e) { |
| return false; |
| } |
| |
| fCommitPage.finish(); |
| return super.performFinish(); |
| } |
| |
| @Override |
| public boolean performCancel() { |
| fCommitPage.finish(); |
| return super.performCancel(); |
| } |
| |
| @Override |
| public void addPages() { |
| |
| final Collection<String> names = new HashSet<>(); |
| final Collection<String> extensions = new HashSet<>(); |
| getUnknownNamesAndExtension(fUnaddedDiffs, names, extensions); |
| |
| if (names.size() + extensions.size() > 0) { |
| fFileTypePage= new CommitWizardFileTypePage(extensions, names); |
| addPage(fFileTypePage); |
| } |
| |
| fCommitPage= new CommitWizardCommitPage(fResources, this); |
| addPage(fCommitPage); |
| |
| super.addPages(); |
| } |
| |
| @Override |
| public void dispose() { |
| fParticipant.dispose(); |
| super.dispose(); |
| } |
| |
| public static void run(IWorkbenchPart part, Shell shell, IResource [] resources) throws CVSException { |
| try { |
| CommitWizard commitWizard = new CommitWizard(resources); |
| commitWizard.setPart(part); |
| run(shell, commitWizard); |
| } catch (OperationCanceledException e) { |
| // Ignore |
| } |
| } |
| |
| private void setPart(IWorkbenchPart part) { |
| this.part = part; |
| } |
| |
| public static void run(Shell shell, SyncInfoSet infos, IJobChangeListener jobListener) throws CVSException { |
| try { |
| run(shell, new CommitWizard(infos, jobListener)); |
| } catch (OperationCanceledException e) { |
| // Ignore |
| } |
| } |
| |
| public static void run(IWorkbenchPart part, Shell shell, final ResourceTraversal[] traversals) throws CVSException { |
| try { |
| final IResource [][] resources = new IResource[][] { null }; |
| PlatformUI.getWorkbench().getProgressService().busyCursorWhile(monitor -> { |
| try { |
| resources[0] = getDeepResourcesToCommit(traversals, monitor); |
| } catch (CoreException e) { |
| throw new InvocationTargetException(e); |
| } |
| }); |
| run(part, shell, resources[0]); |
| } catch (OperationCanceledException e) { |
| // Ignore |
| } catch (InvocationTargetException e) { |
| throw CVSException.wrapException(e); |
| } catch (InterruptedException e) { |
| // Ignore |
| } |
| } |
| |
| private IWorkbenchPart getPart() { |
| if (part != null) |
| return part; |
| return PlatformUI.getWorkbench().getActiveWorkbenchWindow().getPartService().getActivePart(); |
| } |
| |
| private static void run(Shell shell, CommitWizard wizard) { |
| if (!wizard.hasOutgoingChanges()) { |
| MessageDialog.openInformation(shell, CVSUIMessages.CommitWizard_6, CVSUIMessages.CommitWizard_7); // |
| } else { |
| int highestProblemSeverity = wizard.getHighestProblemSeverity(); |
| IPreferenceStore preferenceStore = CVSUIPlugin.getPlugin().getPreferenceStore(); |
| switch (highestProblemSeverity) { |
| case IMarker.SEVERITY_WARNING: |
| String allowCommitsWithWarnings = preferenceStore.getString(ICVSUIConstants.PREF_ALLOW_COMMIT_WITH_WARNINGS); |
| if (MessageDialogWithToggle.PROMPT.equals(allowCommitsWithWarnings) || MessageDialogWithToggle.NEVER.equals(allowCommitsWithWarnings)) { |
| MessageDialogWithToggle warningDialog = MessageDialogWithToggle.openYesNoQuestion(shell, CVSUIMessages.CommitWizard_8, CVSUIMessages.CommitWizard_9, CVSUIMessages.CommitWizard_10, false, preferenceStore, ICVSUIConstants.PREF_ALLOW_COMMIT_WITH_WARNINGS); |
| if (IDialogConstants.YES_ID != warningDialog.getReturnCode()) { |
| return; |
| } |
| } |
| break; |
| case IMarker.SEVERITY_ERROR: |
| String allowCommitsWithErrors = preferenceStore.getString(ICVSUIConstants.PREF_ALLOW_COMMIT_WITH_ERRORS); |
| if (MessageDialogWithToggle.PROMPT.equals(allowCommitsWithErrors) || MessageDialogWithToggle.NEVER.equals(allowCommitsWithErrors)) { |
| MessageDialogWithToggle errorDialog = MessageDialogWithToggle.openYesNoQuestion(shell, CVSUIMessages.CommitWizard_11, CVSUIMessages.CommitWizard_12, CVSUIMessages.CommitWizard_13, false, preferenceStore, ICVSUIConstants.PREF_ALLOW_COMMIT_WITH_ERRORS); |
| if (IDialogConstants.YES_ID != errorDialog.getReturnCode()) { |
| return; |
| } |
| } |
| break; |
| } |
| open(shell, wizard); |
| } |
| } |
| |
| protected static int open(Shell shell, ResizableWizard wizard) { |
| final WizardDialog dialog= new WizardDialog(shell, wizard); |
| dialog.setPageSize(wizard.loadSize()); |
| return dialog.open(); |
| } |
| |
| private void getUnknownNamesAndExtension(IResource[] resources, Collection<String> names, |
| Collection<String> extensions) { |
| |
| final IFileContentManager manager= Team.getFileContentManager(); |
| |
| for (int i = 0; i < resources.length; i++) { |
| |
| IResource local = resources[i]; |
| if (local instanceof IFile && manager.getType((IFile)local) == Team.UNKNOWN) { |
| final String extension= local.getFileExtension(); |
| if (extension != null && !manager.isKnownExtension(extension)) { |
| extensions.add(extension); |
| } |
| |
| final String name= local.getName(); |
| if (extension == null && name != null && !manager.isKnownFilename(name)) |
| names.add(name); |
| } |
| } |
| } |
| |
| private IResource[] getUnaddedResources(IResource[] resources) throws CVSException { |
| List/* <IResource> */<IResource> unadded = new ArrayList<>(); |
| for (int i = 0; i < resources.length; i++) { |
| if (!isAdded(resources[i])) { |
| unadded.add(resources[i]); |
| } |
| } |
| return unadded.toArray(new IResource[0]); |
| } |
| |
| private IResource[] getFiles(IResource[] resources) { |
| final List<IResource> files = new ArrayList<>(); |
| for (int i = 0; i < resources.length; i++) { |
| if (resources[i].getType() == IResource.FILE) |
| files.add(resources[i]); |
| } |
| return files.toArray(new IResource[0]); |
| } |
| |
| private static boolean isAdded(IResource resource) throws CVSException { |
| final ICVSResource cvsResource = CVSWorkspaceRoot.getCVSResourceFor(resource); |
| if (cvsResource.isFolder()) { |
| return ((ICVSFolder)cvsResource).isCVSFolder(); |
| } |
| return cvsResource.isManaged(); |
| } |
| |
| private static IResource[] getDeepResourcesToCommit(ResourceTraversal[] traversals, IProgressMonitor monitor) throws CoreException { |
| List<IResource> roots = new ArrayList<>(); |
| for (int j = 0; j < traversals.length; j++) { |
| ResourceTraversal traversal = traversals[j]; |
| IResource[] resources = traversal.getResources(); |
| if (traversal.getDepth() == IResource.DEPTH_INFINITE) { |
| roots.addAll(Arrays.asList(resources)); |
| } else if (traversal.getDepth() == IResource.DEPTH_ZERO) { |
| collectShallowFiles(resources, roots); |
| } else if (traversal.getDepth() == IResource.DEPTH_ONE) { |
| collectShallowFiles(resources, roots); |
| for (int k = 0; k < resources.length; k++) { |
| IResource resource = resources[k]; |
| if (resource.getType() != IResource.FILE) { |
| collectShallowFiles(members(resource), roots); |
| } |
| } |
| } |
| } |
| return roots.toArray(new IResource[roots.size()]); |
| } |
| |
| private static IResource[] members(IResource resource) throws CoreException { |
| return CVSProviderPlugin.getPlugin().getCVSWorkspaceSubscriber().members(resource); |
| } |
| |
| private static void collectShallowFiles(IResource[] resources, List<IResource> roots) { |
| for (int k = 0; k < resources.length; k++) { |
| IResource resource = resources[k]; |
| if (resource.getType() == IResource.FILE) |
| roots.add(resource); |
| } |
| } |
| } |
| |
