ltk/org.eclipse.statet.ltk.ui/src/org/eclipse/statet/ltk/ui/refactoring/RefactoringExecutionHelper.java - statet/org.eclipse.statet-ltk - Git at Google

 /*=============================================================================#
  # Copyright (c) 2008, 2020 Stephan Wahlbrink and others.
  #
  # This program and the accompanying materials are made available under the
  # terms of the Eclipse Public License 2.0 which is available at
  # https://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
  # which is available at https://www.apache.org/licenses/LICENSE-2.0.
  #
  # SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
  #
  # Contributors:
  #     Stephan Wahlbrink <sw@wahlbrink.eu> - initial API and implementation
  #=============================================================================*/

 package org.eclipse.statet.ltk.ui.refactoring;

 import java.lang.reflect.InvocationTargetException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;

 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.OperationCanceledException;
 import org.eclipse.core.runtime.SubMonitor;
 import org.eclipse.core.runtime.jobs.IJobManager;
 import org.eclipse.core.runtime.jobs.ISchedulingRule;
 import org.eclipse.core.runtime.jobs.Job;
 import org.eclipse.jface.dialogs.Dialog;
 import org.eclipse.jface.dialogs.IDialogConstants;
 import org.eclipse.jface.dialogs.MessageDialog;
 import org.eclipse.jface.operation.IRunnableWithProgress;
 import org.eclipse.jface.text.Position;
 import org.eclipse.ltk.core.refactoring.Change;
 import org.eclipse.ltk.core.refactoring.CompositeChange;
 import org.eclipse.ltk.core.refactoring.PerformChangeOperation;
 import org.eclipse.ltk.core.refactoring.Refactoring;
 import org.eclipse.ltk.core.refactoring.RefactoringCore;
 import org.eclipse.ltk.core.refactoring.RefactoringStatus;
 import org.eclipse.ltk.internal.ui.refactoring.ChangeExceptionHandler;
 import org.eclipse.ltk.ui.refactoring.RefactoringUI;
 import org.eclipse.osgi.util.NLS;
 import org.eclipse.swt.widgets.Display;
 import org.eclipse.swt.widgets.Shell;
 import org.eclipse.ui.progress.IProgressService;

 import org.eclipse.statet.internal.ltk.ui.refactoring.Messages;
 import org.eclipse.statet.ltk.model.core.elements.ISourceUnit;
 import org.eclipse.statet.ltk.refactoring.core.IScheduledRefactoring;
 import org.eclipse.statet.ltk.refactoring.core.SourceUnitChange;


 /**
  * Helper to execute a refactoring. The class takes care of pushing the
  * undo change onto the undo stack and folding editor edits into one editor
  * undo object.
  */
 public class RefactoringExecutionHelper {


 	private final Refactoring refactoring;

 	private final IProgressService execContext;

 	private final Shell parent;
 	private final int stopSeverity;

 	private ISourceUnit insertPositionSourceUnit;
 	private Position insertPosition;


 	/**
 	 * @param refactoring
 	 * @param stopSeverity a refactoring status constant from {@link RefactoringStatus}
 	 * @param parent
 	 * @param context
 	 */
 	public RefactoringExecutionHelper(final Refactoring refactoring, final int stopSeverity, final Shell parent, final IProgressService context) {
 		assert (refactoring != null);
 		assert (parent != null);
 		assert (context != null);

 		this.refactoring= refactoring;
 		this.stopSeverity= stopSeverity;
 		this.parent= parent;
 		this.execContext= context;
 	}


 	/**
 	 * Must be called in the UI thread.<br>
 	 * <strong>Use {@link #perform(boolean, boolean)} unless you know exactly what you are doing!</strong>
 	 *
 	 * @param forkChangeExecution if the change should not be executed in the UI thread: This may not work in any case
 	 * @param cancelable  if set, the operation will be cancelable
 	 * @throws InterruptedException thrown when the operation is cancelled
 	 * @throws InvocationTargetException thrown when the operation failed to execute
 	 */
 	public void perform(final boolean forkChangeExecution, final boolean cancelable) throws InterruptedException, InvocationTargetException {
 		final AtomicReference<PerformChangeOperation> op= new AtomicReference<>();
 		try {
 			this.execContext.busyCursorWhile(new IRunnableWithProgress() {
 				@Override
 				public void run(final IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
 					final SubMonitor m= SubMonitor.convert(monitor, RefactoringExecutionHelper.this.refactoring.getName(), 10);

 					final IJobManager manager=  Job.getJobManager();
 					final Thread workingThread= Thread.currentThread();
 					final ISchedulingRule rule= (RefactoringExecutionHelper.this.refactoring instanceof IScheduledRefactoring) ?
 							((IScheduledRefactoring) RefactoringExecutionHelper.this.refactoring).getSchedulingRule() :
 							ResourcesPlugin.getWorkspace().getRoot();

 					manager.beginRule(rule, m.newChild(1));
 					PerformChangeOperation operation= null;
 					try {
 						if (cancelable && monitor.isCanceled()) {
 							throw new InterruptedException();
 						}

 						RefactoringExecutionHelper.this.refactoring.setValidationContext(RefactoringExecutionHelper.this.parent);

 						final RefactoringStatus status= RefactoringExecutionHelper.this.refactoring.checkAllConditions(
 								m.newChild(1, SubMonitor.SUPPRESS_NONE));
 						if (status.getSeverity() >= RefactoringExecutionHelper.this.stopSeverity) {
 							final AtomicBoolean canceled= new AtomicBoolean();
 							RefactoringExecutionHelper.this.parent.getDisplay().syncExec(new Runnable() {
 								@Override
 								public void run() {
 									final Dialog dialog= RefactoringUI.createRefactoringStatusDialog(status, RefactoringExecutionHelper.this.parent, RefactoringExecutionHelper.this.refactoring.getName(), false);
 									final int selection= dialog.open();
 									canceled.set(selection == IDialogConstants.CANCEL_ID);
 								}
 							});
 							if (canceled.get()) {
 								throw new OperationCanceledException();
 							}
 						}

 						final Change change= RefactoringExecutionHelper.this.refactoring.createChange(
 								m.newChild(2, SubMonitor.SUPPRESS_NONE) );
 						change.initializeValidationData(
 								m.newChild(1, SubMonitor.SUPPRESS_NONE) );

 						final SourceUnitChange insertTracker= (RefactoringExecutionHelper.this.insertPositionSourceUnit != null) ?
 								search(change) : null;

 						operation= new PerformChangeOperation(change);
 						operation.setUndoManager(RefactoringCore.getUndoManager(), RefactoringExecutionHelper.this.refactoring.getName());
 						operation.setSchedulingRule(rule);

 						if (cancelable && monitor.isCanceled()) {
 							throw new InterruptedException();
 						}
 						op.set(operation);

 						if (forkChangeExecution) {
 							operation.run(m.newChild(4, SubMonitor.SUPPRESS_NONE));
 						}
 						else {
 							final AtomicReference<Exception> opException= new AtomicReference<>();
 							final Runnable runnable= new Runnable() {
 								@Override
 								public void run() {
 									try {
 										final PerformChangeOperation operation= op.get();
 										operation.run(m.newChild(4, SubMonitor.SUPPRESS_NONE));
 									}
 									catch (final CoreException e) {
 										opException.set(e);
 									}
 									catch (final RuntimeException e) {
 										opException.set(e);
 									}
 									finally {
 										manager.transferRule(rule, workingThread);
 									}
 								}
 							};
 							final Display display= RefactoringExecutionHelper.this.parent.getDisplay();
 							manager.transferRule(rule, display.getThread());
 							display.syncExec(runnable);
 							if (opException.get() != null) {
 								final Exception e= opException.get();
 								if (e instanceof CoreException) {
 									throw (CoreException) e;
 								}
 								if (e instanceof RuntimeException) {
 									throw (RuntimeException) e;
 								}
 							}
 						}

 						final RefactoringStatus validationStatus= operation.getValidationStatus();
 						if (validationStatus != null && validationStatus.hasFatalError()) {
 							MessageDialog.openError(RefactoringExecutionHelper.this.parent, RefactoringExecutionHelper.this.refactoring.getName(), NLS.bind(
 									Messages.ExecutionHelper_CannotExecute_message,
 									validationStatus.getMessageMatchingSeverity(RefactoringStatus.FATAL) ));
 							return;
 						}

 						if (insertTracker != null) {
 							RefactoringExecutionHelper.this.insertPosition= insertTracker.getInsertPosition();
 						}
 					}
 					catch (final OperationCanceledException e) {
 						throw new InterruptedException(e.getMessage());
 					}
 					catch (final CoreException e) {
 						throw new InvocationTargetException(e);
 					}
 					catch (final RuntimeException e) {
 						throw new InvocationTargetException(e);
 					}
 					finally {
 						manager.endRule(rule);
 						RefactoringExecutionHelper.this.refactoring.setValidationContext(null);
 					}
 				}

 			});
 		}
 		catch (final InvocationTargetException e) {
 			final PerformChangeOperation operation= op.get();
 			if (operation != null && operation.changeExecutionFailed()) {
 				final ChangeExceptionHandler handler= new ChangeExceptionHandler(this.parent, this.refactoring);
 				final Throwable inner= e.getTargetException();
 				if (inner instanceof RuntimeException) {
 					handler.handle(operation.getChange(), (RuntimeException) inner);
 				}
 				else if (inner instanceof CoreException) {
 					handler.handle(operation.getChange(), (CoreException) inner);
 				}
 				else {
 					throw e;
 				}
 			}
 			else {
 				throw e;
 			}
 		}
 	}


 	public void enableInsertPosition(final ISourceUnit su) {
 		this.insertPositionSourceUnit= su;
 	}

 	public Position getInsertPosition() {
 		return this.insertPosition;
 	}

 	private SourceUnitChange search(final Change change) {
 		if (change instanceof SourceUnitChange) {
 			if (((SourceUnitChange) change).getSourceUnit() == this.insertPositionSourceUnit) {
 				return (SourceUnitChange) change;
 			}
 		}
 		if (change instanceof CompositeChange) {
 			final Change[] children= ((CompositeChange) change).getChildren();
 			for (int i= 0; i < children.length; i++) {
 				final SourceUnitChange child= search(children[i]);
 				if (child != null) {
 					return child;
 				}
 			}
 		}
 		return null;
 	}

 }
	/*=============================================================================#
	# Copyright (c) 2008, 2020 Stephan Wahlbrink and others.
	#
	# This program and the accompanying materials are made available under the
	# terms of the Eclipse Public License 2.0 which is available at
	# https://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
	# which is available at https://www.apache.org/licenses/LICENSE-2.0.
	#
	# SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
	#
	# Contributors:
	# Stephan Wahlbrink <sw@wahlbrink.eu> - initial API and implementation
	#=============================================================================*/

	package org.eclipse.statet.ltk.ui.refactoring;

	import java.lang.reflect.InvocationTargetException;
	import java.util.concurrent.atomic.AtomicBoolean;
	import java.util.concurrent.atomic.AtomicReference;

	import org.eclipse.core.resources.ResourcesPlugin;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.OperationCanceledException;
	import org.eclipse.core.runtime.SubMonitor;
	import org.eclipse.core.runtime.jobs.IJobManager;
	import org.eclipse.core.runtime.jobs.ISchedulingRule;
	import org.eclipse.core.runtime.jobs.Job;
	import org.eclipse.jface.dialogs.Dialog;
	import org.eclipse.jface.dialogs.IDialogConstants;
	import org.eclipse.jface.dialogs.MessageDialog;
	import org.eclipse.jface.operation.IRunnableWithProgress;
	import org.eclipse.jface.text.Position;
	import org.eclipse.ltk.core.refactoring.Change;
	import org.eclipse.ltk.core.refactoring.CompositeChange;
	import org.eclipse.ltk.core.refactoring.PerformChangeOperation;
	import org.eclipse.ltk.core.refactoring.Refactoring;
	import org.eclipse.ltk.core.refactoring.RefactoringCore;
	import org.eclipse.ltk.core.refactoring.RefactoringStatus;
	import org.eclipse.ltk.internal.ui.refactoring.ChangeExceptionHandler;
	import org.eclipse.ltk.ui.refactoring.RefactoringUI;
	import org.eclipse.osgi.util.NLS;
	import org.eclipse.swt.widgets.Display;
	import org.eclipse.swt.widgets.Shell;
	import org.eclipse.ui.progress.IProgressService;

	import org.eclipse.statet.internal.ltk.ui.refactoring.Messages;
	import org.eclipse.statet.ltk.model.core.elements.ISourceUnit;
	import org.eclipse.statet.ltk.refactoring.core.IScheduledRefactoring;
	import org.eclipse.statet.ltk.refactoring.core.SourceUnitChange;


	/**
	* Helper to execute a refactoring. The class takes care of pushing the
	* undo change onto the undo stack and folding editor edits into one editor
	* undo object.
	*/
	public class RefactoringExecutionHelper {


	private final Refactoring refactoring;

	private final IProgressService execContext;

	private final Shell parent;
	private final int stopSeverity;

	private ISourceUnit insertPositionSourceUnit;
	private Position insertPosition;


	/**
	* @param refactoring
	* @param stopSeverity a refactoring status constant from {@link RefactoringStatus}
	* @param parent
	* @param context
	*/
	public RefactoringExecutionHelper(final Refactoring refactoring, final int stopSeverity, final Shell parent, final IProgressService context) {
	assert (refactoring != null);
	assert (parent != null);
	assert (context != null);

	this.refactoring= refactoring;
	this.stopSeverity= stopSeverity;
	this.parent= parent;
	this.execContext= context;
	}


	/**
	* Must be called in the UI thread.<br>
	* <strong>Use {@link #perform(boolean, boolean)} unless you know exactly what you are doing!</strong>
	*
	* @param forkChangeExecution if the change should not be executed in the UI thread: This may not work in any case
	* @param cancelable if set, the operation will be cancelable
	* @throws InterruptedException thrown when the operation is cancelled
	* @throws InvocationTargetException thrown when the operation failed to execute
	*/
	public void perform(final boolean forkChangeExecution, final boolean cancelable) throws InterruptedException, InvocationTargetException {
	final AtomicReference<PerformChangeOperation> op= new AtomicReference<>();
	try {
	this.execContext.busyCursorWhile(new IRunnableWithProgress() {
	@Override
	public void run(final IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
	final SubMonitor m= SubMonitor.convert(monitor, RefactoringExecutionHelper.this.refactoring.getName(), 10);

	final IJobManager manager= Job.getJobManager();
	final Thread workingThread= Thread.currentThread();
	final ISchedulingRule rule= (RefactoringExecutionHelper.this.refactoring instanceof IScheduledRefactoring) ?
	((IScheduledRefactoring) RefactoringExecutionHelper.this.refactoring).getSchedulingRule() :
	ResourcesPlugin.getWorkspace().getRoot();

	manager.beginRule(rule, m.newChild(1));
	PerformChangeOperation operation= null;
	try {
	if (cancelable && monitor.isCanceled()) {
	throw new InterruptedException();
	}

	RefactoringExecutionHelper.this.refactoring.setValidationContext(RefactoringExecutionHelper.this.parent);

	final RefactoringStatus status= RefactoringExecutionHelper.this.refactoring.checkAllConditions(
	m.newChild(1, SubMonitor.SUPPRESS_NONE));
	if (status.getSeverity() >= RefactoringExecutionHelper.this.stopSeverity) {
	final AtomicBoolean canceled= new AtomicBoolean();
	RefactoringExecutionHelper.this.parent.getDisplay().syncExec(new Runnable() {
	@Override
	public void run() {
	final Dialog dialog= RefactoringUI.createRefactoringStatusDialog(status, RefactoringExecutionHelper.this.parent, RefactoringExecutionHelper.this.refactoring.getName(), false);
	final int selection= dialog.open();
	canceled.set(selection == IDialogConstants.CANCEL_ID);
	}
	});
	if (canceled.get()) {
	throw new OperationCanceledException();
	}
	}

	final Change change= RefactoringExecutionHelper.this.refactoring.createChange(
	m.newChild(2, SubMonitor.SUPPRESS_NONE) );
	change.initializeValidationData(
	m.newChild(1, SubMonitor.SUPPRESS_NONE) );

	final SourceUnitChange insertTracker= (RefactoringExecutionHelper.this.insertPositionSourceUnit != null) ?
	search(change) : null;

	operation= new PerformChangeOperation(change);
	operation.setUndoManager(RefactoringCore.getUndoManager(), RefactoringExecutionHelper.this.refactoring.getName());
	operation.setSchedulingRule(rule);

	if (cancelable && monitor.isCanceled()) {
	throw new InterruptedException();
	}
	op.set(operation);

	if (forkChangeExecution) {
	operation.run(m.newChild(4, SubMonitor.SUPPRESS_NONE));
	}
	else {
	final AtomicReference<Exception> opException= new AtomicReference<>();
	final Runnable runnable= new Runnable() {
	@Override
	public void run() {
	try {
	final PerformChangeOperation operation= op.get();
	operation.run(m.newChild(4, SubMonitor.SUPPRESS_NONE));
	}
	catch (final CoreException e) {
	opException.set(e);
	}
	catch (final RuntimeException e) {
	opException.set(e);
	}
	finally {
	manager.transferRule(rule, workingThread);
	}
	}
	};
	final Display display= RefactoringExecutionHelper.this.parent.getDisplay();
	manager.transferRule(rule, display.getThread());
	display.syncExec(runnable);
	if (opException.get() != null) {
	final Exception e= opException.get();
	if (e instanceof CoreException) {
	throw (CoreException) e;
	}
	if (e instanceof RuntimeException) {
	throw (RuntimeException) e;
	}
	}
	}

	final RefactoringStatus validationStatus= operation.getValidationStatus();
	if (validationStatus != null && validationStatus.hasFatalError()) {
	MessageDialog.openError(RefactoringExecutionHelper.this.parent, RefactoringExecutionHelper.this.refactoring.getName(), NLS.bind(
	Messages.ExecutionHelper_CannotExecute_message,
	validationStatus.getMessageMatchingSeverity(RefactoringStatus.FATAL) ));
	return;
	}

	if (insertTracker != null) {
	RefactoringExecutionHelper.this.insertPosition= insertTracker.getInsertPosition();
	}
	}
	catch (final OperationCanceledException e) {
	throw new InterruptedException(e.getMessage());
	}
	catch (final CoreException e) {
	throw new InvocationTargetException(e);
	}
	catch (final RuntimeException e) {
	throw new InvocationTargetException(e);
	}
	finally {
	manager.endRule(rule);
	RefactoringExecutionHelper.this.refactoring.setValidationContext(null);
	}
	}

	});
	}
	catch (final InvocationTargetException e) {
	final PerformChangeOperation operation= op.get();
	if (operation != null && operation.changeExecutionFailed()) {
	final ChangeExceptionHandler handler= new ChangeExceptionHandler(this.parent, this.refactoring);
	final Throwable inner= e.getTargetException();
	if (inner instanceof RuntimeException) {
	handler.handle(operation.getChange(), (RuntimeException) inner);
	}
	else if (inner instanceof CoreException) {
	handler.handle(operation.getChange(), (CoreException) inner);
	}
	else {
	throw e;
	}
	}
	else {
	throw e;
	}
	}
	}



	public void enableInsertPosition(final ISourceUnit su) {
	this.insertPositionSourceUnit= su;
	}

	public Position getInsertPosition() {
	return this.insertPosition;
	}

	private SourceUnitChange search(final Change change) {
	if (change instanceof SourceUnitChange) {
	if (((SourceUnitChange) change).getSourceUnit() == this.insertPositionSourceUnit) {
	return (SourceUnitChange) change;
	}
	}
	if (change instanceof CompositeChange) {
	final Change[] children= ((CompositeChange) change).getChildren();
	for (int i= 0; i < children.length; i++) {
	final SourceUnitChange child= search(children[i]);
	if (child != null) {
	return child;
	}
	}
	}
	return null;
	}

	}