com.github.parzonka.ccms.handler.BatchProcessingHandler.java Source code

Introduction

Here is the source code for com.github.parzonka.ccms.handler.BatchProcessingHandler.java

Source

/**
 * Copyright (c) 2011 Mateusz Parzonka
 * 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 com.github.parzonka.ccms.handler;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
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.JavaModelException;
import org.eclipse.jdt.internal.core.CompilationUnit;
import org.eclipse.jdt.internal.core.JavaProject;
import org.eclipse.jdt.internal.core.PackageFragment;
import org.eclipse.jdt.internal.core.PackageFragmentRoot;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.handlers.HandlerUtil;

import com.github.parzonka.ccms.sorter.CleanCodeMethodSorter;
import com.github.parzonka.ccms.sorter.IMethodSorter;
import com.github.parzonka.ccms.sorter.callgraph.ASTUtils;

/**
 *
 * @author Mateusz Parzonka
 *
 */
public class BatchProcessingHandler extends AbstractHandler {

    private IMethodSorter fMethodSorter;
    protected int sortedClassesCount;
    private ExecutionEvent event;

    public BatchProcessingHandler() {
        super();
        fMethodSorter = getMethodSorter();
    }

    protected IMethodSorter getMethodSorter() {
        return new CleanCodeMethodSorter();
    }

    @Override
    public Object execute(ExecutionEvent event) throws ExecutionException {

        sortedClassesCount = 0;
        this.event = event;

        ISelection currentSelection = HandlerUtil.getCurrentSelection(event);
        if (currentSelection instanceof IStructuredSelection) {

            IStructuredSelection structuredSelection = (IStructuredSelection) HandlerUtil
                    .getCurrentSelection(event);
            IJavaElement[] elements = getJavaElements(structuredSelection);
            sort(elements);
        } else {
            IWorkbenchWindow window = HandlerUtil.getActiveWorkbenchWindowChecked(event);
            ICompilationUnit cu = ASTUtils.getCompilationUnit(window);
            sort(cu);
        }

        MessageDialog.openInformation(HandlerUtil.getActiveWorkbenchWindow(event).getShell(),
                "Clean Code Method Sorter", getMessage());

        return null;
    }

    /**
     * Converts the given structured selection into an array of Java elements.
     * structured selection is not of type <code>IJavaElement</code> it is not
     * included into the list.
     *
     * @param selection
     *            the selection
     * @return the Java element contained in the selection
     */
    private static IJavaElement[] getJavaElements(IStructuredSelection selection) {

        List<IJavaElement> result = new ArrayList<IJavaElement>();
        Iterator<?> iter = selection.iterator();
        while (iter.hasNext()) {
            Object element = iter.next();
            if (element instanceof IJavaElement)
                result.add((IJavaElement) element);
        }
        return result.toArray(new IJavaElement[result.size()]);
    }

    /**
     * @param event
     * @param store
     * @param elements
     * @throws ExecutionException
     */
    private void sort(IJavaElement[] elements) throws ExecutionException {

        for (IJavaElement iJavaElement : elements) {

            if (iJavaElement instanceof CompilationUnit) {
                sort((CompilationUnit) iJavaElement);

            } else if (iJavaElement instanceof PackageFragmentRoot) {
                sort((PackageFragmentRoot) iJavaElement);

            } else if (iJavaElement instanceof PackageFragment) {
                sort((PackageFragment) iJavaElement);

            } else if (iJavaElement instanceof JavaProject) {
                sort((JavaProject) iJavaElement);

            } else {
                MessageDialog.openInformation(HandlerUtil.getActiveWorkbenchWindow(event).getShell(),
                        "Clean Code Method Sorter",
                        iJavaElement.getClass().getCanonicalName() + "\n" + iJavaElement.getElementName());
            }
        }
    }

    private void sort(IPackageFragmentRoot packageFragmentRoot) throws ExecutionException {
        try {
            sort(packageFragmentRoot.getChildren());
        } catch (JavaModelException e) {
            throw new ExecutionException(e.getMessage());
        }
    }

    private void sort(PackageFragment packageFragment) throws ExecutionException {
        try {
            sort(packageFragment.getCompilationUnits());
        } catch (JavaModelException e) {
            throw new ExecutionException(e.getMessage());
        }
    }

    private void sort(IJavaProject iJavaElement) throws ExecutionException {
        try {
            for (IPackageFragmentRoot root : iJavaElement.getAllPackageFragmentRoots()) {
                if (root instanceof PackageFragmentRoot)
                    sort(root);
            }
        } catch (JavaModelException e) {
            throw new ExecutionException(e.getMessage());
        }
    }

    /**
     * Sorts a single CompilationUnit.
     *
     * @param cu
     * @throws ExecutionException
     */
    private void sort(ICompilationUnit cu) throws ExecutionException {
        try {
            cu.becomeWorkingCopy(null);
            fMethodSorter.sort(cu);
            sortedClassesCount++;
            cu.commitWorkingCopy(true, null);
            cu.discardWorkingCopy();
        } catch (JavaModelException e) {
            throw new ExecutionException(e.getMessage());
        }
    }

    protected String getMessage() {
        StringBuilder sb = new StringBuilder();
        sb.append("Methods sorted in " + sortedClassesCount + " classes.");
        return sb.toString();
    }

}