CreateNewSuperclassCommandHandler.java

/**
 * Copyright (c) 2008-2012 University of Illinois at Urbana-Champaign.
 * 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 edu.illinois.compositerefactorings.steps;

import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.corext.refactoring.JavaRefactoringDescriptorUtil;
import org.eclipse.jdt.internal.corext.refactoring.util.JavaElementUtil;
import org.eclipse.jdt.internal.corext.util.JavaModelUtil;
import org.eclipse.jdt.internal.ui.actions.SelectionConverter;
import org.eclipse.jdt.internal.ui.javaeditor.CompilationUnitEditor;
import org.eclipse.jdt.ui.JavaUI;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.window.Window;
import org.eclipse.ltk.core.refactoring.CheckConditionsOperation;
import org.eclipse.ltk.core.refactoring.PerformRefactoringOperation;
import org.eclipse.ltk.core.refactoring.RefactoringDescriptor;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.ltk.internal.ui.refactoring.RefactoringStatusDialog;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.handlers.HandlerUtil;

import edu.illinois.compositerefactorings.messages.CompositeRefactoringsMessages;
import edu.illinois.compositerefactorings.refactorings.createnewtoplevelsuperclass.CreateNewTopLevelSuperClassDescriptor;
import edu.illinois.compositerefactorings.refactorings.createnewtoplevelsuperclass.CreateNewTopLevelSuperClassRefactoring;

@SuppressWarnings("restriction")
public class CreateNewSuperclassCommandHandler extends AbstractHandler {

	@SuppressWarnings("serial")
	public static class InvalidSelectionException extends Exception {

		public InvalidSelectionException(String message) {
			super(message);
		}

	}

//	private static Set<String> fullyQualifiedName(List<IType> types) {
//		Set<String> fullyQualifiedNames= new HashSet<String>();
//		for (IType type : types) {
//			fullyQualifiedNames.add(type.getFullyQualifiedName());
//		}
//		return fullyQualifiedNames;
//	}

	@Override
	public Object execute(ExecutionEvent event) throws ExecutionException {
		// See http://wiki.bioclipse.net/index.php?title=How_to_add_menus_and_actions&oldid=4857
		Shell shell= HandlerUtil.getActiveShell(event);
		IEditorPart editorPart= HandlerUtil.getActiveEditor(event);
		ISelection selection= HandlerUtil.getCurrentSelection(event);
		try {
			List<IType> selectedTypes= getSelectedTypes(editorPart, selection);
			CreateNewTopLevelSuperClassRefactoring refactoring= createRefactoring(selectedTypes);
			IProgressMonitor monitor= new NullProgressMonitor();
			RefactoringStatus status= checkRefactoring(selectedTypes, refactoring, monitor);
			if (status.isOK() || choseToProceed(shell, status)) {
				performRefactoring(refactoring, monitor);
				openNewSuperClass(selectedTypes);
			}
		} catch (JavaModelException e) {
			throw new ExecutionException("Unexpected selection", e);
		} catch (CoreException e) {
			throw new ExecutionException("Refactoring object creation failed.", e);
		} catch (InvalidSelectionException e) {
			MessageDialog.openError(shell, "Unavailable Refactoring", e.getMessage());
		}
		return null;
	}

	private static void openNewSuperClass(List<IType> selectedTypes) throws JavaModelException, PartInitException {
		JavaUI.openInEditor(findNewType(selectedTypes.get(0)));
	}

	private static void performRefactoring(CreateNewTopLevelSuperClassRefactoring refactoring, IProgressMonitor monitor) throws CoreException {
		PerformRefactoringOperation operation= new PerformRefactoringOperation(refactoring, CheckConditionsOperation.INITIAL_CONDITONS);
		operation.run(monitor);
	}

	private static RefactoringStatus checkRefactoring(List<IType> selectedTypes, CreateNewTopLevelSuperClassRefactoring refactoring, IProgressMonitor monitor) throws CoreException {
		RefactoringStatus status= new RefactoringStatus();
		status.merge(refactoring.checkInitialConditions(monitor));
		status.merge(refactoring.checkFinalConditions(monitor));
//		I (Mohsen) disabled the following check because it is too expensive.
//		status.merge(areSelectedTypesCompatible(refactoring, selectedTypes, monitor));
		return status;
	}

	private static CreateNewTopLevelSuperClassRefactoring createRefactoring(List<IType> selectedTypes) throws CoreException {
		CreateNewTopLevelSuperClassDescriptor descriptor= createRefactoringDescriptor(selectedTypes);
		CreateNewTopLevelSuperClassRefactoring refactoring= (CreateNewTopLevelSuperClassRefactoring)descriptor.createRefactoringContext(new RefactoringStatus()).getRefactoring();
		return refactoring;
	}

	private static List<IType> getSelectedTypes(IEditorPart editorPart, ISelection selection) throws InvalidSelectionException, JavaModelException {
		List<IType> selectedTypes;
		if (selection instanceof ITextSelection) {
			selectedTypes= getSelectedTypes(editorPart, (ITextSelection)selection);
		} else if (selection instanceof IStructuredSelection) {
			selectedTypes= getSelectedTypes((IStructuredSelection)selection);
		} else {
			throw new InvalidSelectionException("Unexpected kind of selection");
		}
		return selectedTypes;
	}

//	private static RefactoringStatus areSelectedTypesCompatible(CreateNewTopLevelSuperClassRefactoring refactoring, List<IType> selectedTypes, IProgressMonitor monitor) {
//		RefactoringStatus status= new RefactoringStatus();
//		List<IType> possibleTypes= Arrays.asList(refactoring.getCandidateTypes(monitor));
//		if (!fullyQualifiedName(possibleTypes).containsAll(fullyQualifiedName(selectedTypes))) {
//			status.merge(RefactoringStatus.createErrorStatus("The selected types belong to different class hierarchies."));
//		}
//		return status;
//	}

	private boolean choseToProceed(Shell shell, RefactoringStatus status) {
		return new RefactoringStatusDialog(status, shell, "Refactoring Problems", false).open() == Window.OK;
	}

	// See http://publib.boulder.ibm.com/infocenter/iadthelp/v6r0/index.jsp?topic=/org.eclipse.jdt.doc.isv/guide/jdt_api_open_editor.htm
	private static IType findNewType(IType firstSelectedType) {
		return firstSelectedType.getPackageFragment().getCompilationUnit("Super" + firstSelectedType.getElementName() + JavaModelUtil.DEFAULT_CU_SUFFIX).findPrimaryType();
	}

	public static List<IType> getSelectedTypes(IEditorPart editorPart, ITextSelection selection) throws InvalidSelectionException, JavaModelException {
		CompilationUnitEditor editor;
		if (editorPart instanceof CompilationUnitEditor) {
			editor= (CompilationUnitEditor)editorPart;
		} else {
			throw new InvalidSelectionException("The active editor is not for editing Java compilation units.");
		}
		IType selectedType= SelectionConverter.getTypeAtOffset(editor);
		if (selectedType != null) {
			return Arrays.asList(selectedType);
		} else {
			throw new InvalidSelectionException("No Java types were selected.");
		}
	}

	private static List<IType> getSelectedTypes(IStructuredSelection selection) throws JavaModelException, InvalidSelectionException {
		List<IType> selectedTypes= new ArrayList<IType>();
		for (Object selectionElement : selection.toList()) {
			selectedTypes.add(extractTypeFromSelection(selectionElement));
		}
		return selectedTypes;
	}

	// See org.eclipse.jdt.internal.corext.refactoring.RefactoringAvailabilityTester.getSingleSelectedType(IStructuredSelection)
	private static IType extractTypeFromSelection(Object selectionElement) throws JavaModelException, InvalidSelectionException {
		if (selectionElement instanceof IType)
			return (IType)selectionElement;
		if (selectionElement instanceof ICompilationUnit) {
			final ICompilationUnit unit= (ICompilationUnit)selectionElement;
			if (unit.exists()) {
				return JavaElementUtil.getMainType(unit);
			}
		}
		throw new InvalidSelectionException(selectionElement + " is not a Java type.");
	}

	private static String typeNames(List<IType> types) {
		StringBuilder sb= new StringBuilder();
		for (Iterator<IType> iterator= types.iterator(); iterator.hasNext();) {
			IType type= (IType)iterator.next();
			sb.append(type.getElementName());
			if (iterator.hasNext()) {
				sb.append(",");
			}
		}
		return sb.toString();
	}

	public static CreateNewTopLevelSuperClassDescriptor createRefactoringDescriptor(List<IType> types) {
		IJavaProject javaProject= types.get(0).getJavaProject();
		String description= MessageFormat.format(CompositeRefactoringsMessages.CreateNewTopLevelSuperClass_description, typeNames(types));
		Map<String, String> arguments= new HashMap<String, String>();
		arguments.put(JavaRefactoringDescriptorUtil.ATTRIBUTE_INPUT, JavaRefactoringDescriptorUtil.elementToHandle(javaProject.getElementName(), types.get(0)));
		org.eclipse.jdt.internal.core.refactoring.descriptors.JavaRefactoringDescriptorUtil.setJavaElementArray(arguments, CreateNewTopLevelSuperClassDescriptor.ATTRIBUTE_TYPES,
				JavaRefactoringDescriptorUtil.ATTRIBUTE_ELEMENT, javaProject.getElementName(), types.toArray(new IType[] {}), 1);
		arguments.put(JavaRefactoringDescriptorUtil.ATTRIBUTE_NAME, "Super" + types.get(0).getElementName());
		CreateNewTopLevelSuperClassDescriptor descriptor= new CreateNewTopLevelSuperClassDescriptor(javaProject.getElementName(), description, null, arguments,
				RefactoringDescriptor.STRUCTURAL_CHANGE | RefactoringDescriptor.MULTI_CHANGE);
		return descriptor;
	}

}