OpenTestingPairAction.java

package junit.extensions.eclipse.quick.internal.action;

import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

import junit.extensions.eclipse.quick.JavaElements;
import junit.extensions.eclipse.quick.JavaTypes;
import junit.extensions.eclipse.quick.NamingRules;
import junit.extensions.eclipse.quick.TestingPair;
import junit.extensions.eclipse.quick.internal.ExtensionSupport;
import junit.extensions.eclipse.quick.internal.HelpSupport;
import junit.extensions.eclipse.quick.internal.Messages;
import junit.extensions.eclipse.quick.internal.PopupTableSelector;
import junit.extensions.eclipse.quick.internal.QuickJUnitPlugin;

import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.jdt.core.IClassFile;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.junit.wizards.NewTestCaseWizardPageOne;
import org.eclipse.jdt.ui.JavaUI;
import org.eclipse.jdt.ui.wizards.NewTypeWizardPage;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.wizard.IWizard;
import org.eclipse.jface.wizard.IWizardPage;
import org.eclipse.jface.wizard.WizardDialog;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchWizard;
import org.eclipse.ui.IWorkingSet;
import org.eclipse.ui.PlatformUI;

public class OpenTestingPairAction extends QuickJUnitAction {
    public static final String NEW_WIZARD_SHORTCUT = PlatformUI.PLUGIN_ID
	        + ".new_wizard_shortcut_context"; //$NON-NLS-1$

    private IType getTypeOfJavaEditor() throws JavaModelException {
        IJavaElement element = getElementOfJavaEditor();
        if (element == null)
            return null;
        IType type = (IType) element.getAncestor(IJavaElement.TYPE);
        if (type != null)
            return type;
        ICompilationUnit unit = getCompilationUnitOfJavaEditor();
        if (unit == null)
            return null;
        return unit.findPrimaryType();
    }

    private IType getTypeOfJavaElement() {
        return JavaElements.getPrimaryTypeOf(javaElement);
    }

    private IType getTargetType() throws JavaModelException {
        IType targetType = getTypeOfJavaEditor();
        if (targetType != null)
            return targetType;
        return getTypeOfJavaElement();
    }

    private static class TypeLabelProvider extends LabelProvider {
        public String getText(Object element) {
            return ((IType) element).getFullyQualifiedName();
        }
    }

    private IType selectType(IAction action, List types) {
        PopupTableSelector selector = new PopupTableSelector(getShell(), types);
        selector.setTitle(action.getText());
        selector.setCommandForward(action.getActionDefinitionId());
        selector.setLabelProvider(new TypeLabelProvider());
        return (IType) selector.select();
    }

    private void openPairWizard(IType targetType, String[] pairNames) throws CoreException, JavaModelException {
        IWorkbench workbench = PlatformUI.getWorkbench();
        IWizard wizard = createNewPairWizard(targetType, workbench);
		Shell parent = workbench.getActiveWorkbenchWindow().getShell();
		WizardDialog dialog = new WizardDialog(parent, wizard);
		dialog.create();
		NewTypeWizardPage page = getNewTypeWizardPage(wizard);
		if(page == null) return;
		setUpSourceFolderWizard(page,targetType);
		setUpNewClassCreationWizard(page,pairNames);
		if (page instanceof NewTestCaseWizardPageOne) {
			NewTestCaseWizardPageOne testCasePage = (NewTestCaseWizardPageOne) page;
			boolean isJUnit4 = testCasePage.isJUnit4();
			if(isJUnit4){
				testCasePage.setSuperClass("java.lang.Object", true);
			}
		}
		HelpSupport.setHelp(dialog.getShell(), NEW_WIZARD_SHORTCUT);
		dialog.open();
    }

	private NewTypeWizardPage getNewTypeWizardPage(IWizard wizard) {
		IWizardPage page = wizard.getPages()[0];
		if (page instanceof NewTypeWizardPage) {
			return (NewTypeWizardPage) page;
		}else{
            QuickJUnitPlugin.getDefault().handleSystemError(new ClassCastException(), this);
            return null;
		}
	}

    private void setUpSourceFolderWizard(NewTypeWizardPage page, IType targetType) {
    	if(isJavaTest(targetType)) return;
        IJavaProject javaProject = targetType.getJavaProject();
        IPackageFragmentRoot[] roots = getPackageFragmentRoots(javaProject);
        for (int i = 0; i < roots.length; i++) {
			IPackageFragmentRoot root = roots[i];
			String str = root.getPath().makeRelative().toString();
			if(str.indexOf("test") != -1){
				page.setPackageFragmentRoot(root,true);
				return;
			}
		}
    }

	private boolean isJavaTest(IType targetType) {
		boolean isTest = false;
		try {
    		isTest = JavaTypes.isTest(targetType);
		} catch (Exception e){
        	QuickJUnitPlugin.getDefault().handleSystemError(e, this);
		}
		return isTest;
	}

	private IPackageFragmentRoot[] getPackageFragmentRoots(IJavaProject javaProject) {
		IPackageFragmentRoot[] roots = new IPackageFragmentRoot[0];
		try {
			roots = javaProject.getPackageFragmentRoots();
		} catch (Exception e){
        	QuickJUnitPlugin.getDefault().handleSystemError(e, this);
		}
		return roots;
	}

	private String extractTypeName(String fullName) {
        int index = fullName.lastIndexOf('.');
        if (index == -1)
            return fullName;
        return fullName.substring(index + 1);
    }
    
    private void setUpNewClassCreationWizard(NewTypeWizardPage page, String[] pairNames) {
        if (pairNames.length == 0)
            return;
        String typeName = extractTypeName(pairNames[0]);
    	page.setTypeName(typeName, true);
    }

    private IWizard createNewPairWizard(IType targetType, IWorkbench workbench) throws CoreException, JavaModelException {
        if (JavaTypes.isTest(targetType)) {
            IWorkbenchWizard wizard = ExtensionSupport.createNewClassCreationWizard();
            IStructuredSelection selection = new StructuredSelection(targetType.getPackageFragment());
            wizard.init(workbench, selection);
            return wizard;
        }
        else {
            IWorkbenchWizard wizard = ExtensionSupport.createNewTestCaseCreationWizard();
            IStructuredSelection selection = new StructuredSelection(targetType);
            wizard.init(workbench, selection);
            return wizard;
        }
    }

    public void run(IAction action) {
        try {
            IType targetType = getTargetType();
            if (targetType == null)
                return;

            String[] pairNames = createTestPair().getPairClassNames(targetType.getFullyQualifiedName());
            List testPairTypes = findPairTypes(pairNames);
            if (testPairTypes.isEmpty()) {
                runWhenTestingPairNotExist(action, targetType, pairNames);
            } else {
                openTestingPair(action, testPairTypes);
            }
        } catch (JavaModelException e) {
            QuickJUnitPlugin.getDefault().handleSystemError(e, this);
        } catch (CoreException e) {
            QuickJUnitPlugin.getDefault().handleSystemError(e, this);
        }
    }

    private List findPairTypes(String[] pairNames) throws JavaModelException {
    	Set foundTypes = findCurrentProject(pairNames);
        if(foundTypes != null && foundTypes.isEmpty() == false){
        	return new ArrayList(foundTypes);
        }
        return new ArrayList(findWorkspace(pairNames));
    }

	private Set findWorkspace(String[] pairNames) throws JavaModelException {
		Set result = new LinkedHashSet();
        IJavaProject[] projects = getJavaProjects();
        for (int i = 0; i < projects.length; ++i) {
            IJavaProject project = projects[i];
            if(project.equals(getCurrentProject())){
            	continue;
            }
            Set foundTypes = findType(pairNames, project);
            result.addAll(foundTypes);
        }
        return result;
	}

	private Set findCurrentProject(String[] pairNames) throws JavaModelException {
		IJavaProject project = getCurrentProject();
        Set foundTypes = findType(pairNames, project);
		return foundTypes;
	}

	private IJavaProject getCurrentProject() throws JavaModelException {
		return getCompilationUnitOfJavaEditor().getJavaProject();
	}

	private Set findType(String[] pairNames, IJavaProject project)
			throws JavaModelException {
		Set result = new LinkedHashSet();
		for (int j = 0; j < pairNames.length; ++j) {
		    IType pairType= project.findType(pairNames[j]);
		    if (pairType == null || pairType instanceof IClassFile) continue;
		    result.add(pairType);
		}
		return result;
	}
    
    protected IJavaProject[] getJavaProjects() throws JavaModelException {
    	IWorkingSet[] workingSets = PlatformUI.getWorkbench().getWorkingSetManager().getWorkingSets();
    	if(workingSets == null) return JavaCore.create(ResourcesPlugin.getWorkspace().getRoot()).getJavaProjects();
    	List result = new ArrayList();
    	for (int i = 0; i < workingSets.length; i++) {
			IWorkingSet workingSet = workingSets[i];
			if(workingSet.isVisible() == false) continue;
			IAdaptable[] adaptables = workingSet.getElements();
			for (int j = 0; j < adaptables.length; j++) {
				IAdaptable adaptable = adaptables[j];
				IJavaProject javaProject = (IJavaProject) adaptable.getAdapter(IJavaProject.class);
				if(javaProject != null)	result.add(javaProject);
			}
		}
    	return (IJavaProject[]) result.toArray(new IJavaProject[]{});
    }

    private void runWhenTestingPairNotExist(IAction action, IType targetType, String[] pairNames) throws CoreException, JavaModelException {
        if (pairNames.length == 0) {
            openInformation(action, Messages.getString(
                    "OpenTestingPairAction.testPairNotFound", targetType.getFullyQualifiedName())); //$NON-NLS-1$
            return;
        }
        if (MessageDialog.openQuestion(getShell(), action.getText(), Messages
                .getString("OpenTestingPairAction.testPairNotFoundAndConfirm"))) { //$NON-NLS-1$
            openPairWizard(targetType, pairNames);
        }
    }

    private void openTestingPair(IAction action, List testPairTypes) throws CoreException {
        IType selectedType = null;
        if (testPairTypes.size() >= 2) {
            selectedType = selectType(action, testPairTypes);
        } else {
            selectedType = (IType) testPairTypes.get(0);
        }
        if (selectedType == null)
            return;
        JavaUI.openInEditor(selectedType,true,false);
    }

    private TestingPair createTestPair() {
        TestingPair testPair = new TestingPair();
        IPreferenceStore store = QuickJUnitPlugin.getDefault().getPreferenceStore();
        String[] rules = new NamingRules(store).getEnableValues();
        for (int i = 0; i < rules.length; ++i) {
            testPair.addNamingRule(rules[i]);            
        }
        return testPair;
    }

}