org.springframework.ide.eclipse.ajdt.ui.actions.SpringAspectsToolingEnabler.java Source code

Java tutorial

Introduction

Here is the source code for org.springframework.ide.eclipse.ajdt.ui.actions.SpringAspectsToolingEnabler.java

Source

/*******************************************************************************
 * Copyright (c) 2008, 2010 Spring IDE Developers
 * 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
 *
 * Contributors:
 *     Spring IDE Developers - initial API and implementation
 *******************************************************************************/
package org.springframework.ide.eclipse.ajdt.ui.actions;

import java.util.regex.Pattern;

import org.eclipse.ajdt.core.AspectJCorePreferences;
import org.eclipse.ajdt.internal.ui.editor.AspectJEditor;
import org.eclipse.ajdt.internal.ui.lazystart.Utils;
import org.eclipse.ajdt.internal.utils.AJDTUtils;
import org.eclipse.core.internal.content.ContentTypeManager;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.jdt.core.IClasspathContainer;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IEditorDescriptor;
import org.eclipse.ui.IFileEditorMapping;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.internal.registry.EditorDescriptor;
import org.eclipse.ui.internal.registry.EditorRegistry;
import org.eclipse.ui.internal.registry.FileEditorMapping;
import org.springframework.ide.eclipse.core.SpringCore;

/**
 * @author Christian Dupuis
 * @author Andrew Eisenberg
 * @since 2.2.1
 */
@SuppressWarnings("restriction")
public class SpringAspectsToolingEnabler {

    // the stand alone spring aspects jar name
    final private static Pattern SPRING_ASPECTS_JAR_PATTERN = Pattern.compile(".*spring-aspects.*\\.jar");
    final private static String SPRING_ASPECTS_JAR_NAME = "spring-aspects.jar";

    // part of the name for the spring aspects jar included in BRITS.
    // the full name includes a version number at the end
    final private static Pattern SPRING_ASPECTS_PATTERN = Pattern
            .compile(".*org\\.springframework\\.aspects-.*\\.jar");

    final private IProject project;

    final private IJavaProject jProject;

    final private Shell shell;

    final private boolean askToChangeDefaultEditor;

    public SpringAspectsToolingEnabler(IProject project, Shell shell) {
        this(project, shell, false);
    }

    public SpringAspectsToolingEnabler(IProject project, Shell shell, boolean askToChangeDefaultEditor) {
        this.project = project;
        this.jProject = JavaCore.create(project);
        this.askToChangeDefaultEditor = askToChangeDefaultEditor;
        this.shell = shell;
    }

    boolean run() {
        boolean isAJEditorDefault = false;
        try {
            if (hasSpringAspectsJar(jProject.getRawClasspath())) {
                if (!hasAJNature()) {
                    AJDTUtils.addAspectJNature(project, false);
                }

                if (!isJarOnAspectPath(jProject.getRawClasspath())) {
                    IClasspathEntry springAspectsEntry = findSpringAspectsJar(jProject.getRawClasspath());
                    AspectJCorePreferences.addToAspectPath(project, springAspectsEntry);
                }

                if (askToChangeDefaultEditor) {
                    if (!isAJEditorDefault()) {
                        isAJEditorDefault = MessageDialog.openQuestion(shell, "Make AspectJ editor default?",
                                "Do you want to make the AspectJ editor the default editor for editing Java files?\n\n"
                                        + "This option can be changed by going to Preferences -> General-> Editors -> File Associations");
                        if (isAJEditorDefault) {
                            makeAJEditorDefault();
                        }
                    } else {
                        isAJEditorDefault = true;
                    }
                }
            } else {
                // can't do anything unless
                // spring jar is on build path
                MessageDialog.openInformation(shell, "Add " + SPRING_ASPECTS_JAR_NAME + " to build path",
                        "Please add a version of " + SPRING_ASPECTS_JAR_NAME + "\nto build path of "
                                + project.getName() + " and run this command again.");

            }
        } catch (CoreException e) {
            SpringCore.log("Error adding Spring tools to project " + project, e);
        }
        return isAJEditorDefault;
    }

    private void makeAJEditorDefault() {
        EditorRegistry registry = (EditorRegistry) PlatformUI.getWorkbench().getEditorRegistry();

        IFileEditorMapping[] mappings = registry.getFileEditorMappings();
        for (IFileEditorMapping mapping : mappings) {
            if (mapping.getExtension().equals("java")) {
                if (mapping instanceof FileEditorMapping) {
                    IEditorDescriptor desc = registry.findEditor(AspectJEditor.ASPECTJ_EDITOR_ID);
                    ((FileEditorMapping) mapping).setDefaultEditor((EditorDescriptor) desc);
                }
            }
        }
        registry.setFileEditorMappings((FileEditorMapping[]) mappings);
        registry.saveAssociations();
    }

    private IClasspathEntry findSpringAspectsJar(IClasspathEntry[] entries) throws JavaModelException {
        for (IClasspathEntry entry : entries) {
            if (isSpringAspectsEntry(entry)) {
                return entry;
            } else if (entry.getEntryKind() == IClasspathEntry.CPE_CONTAINER) {
                IClasspathEntry containedEntry = findSpringAspectsJar(extractEntriesFomContainer(entry));
                if (containedEntry != null) {
                    return containedEntry;
                }
            }
        }
        return null;
    }

    private boolean hasSpringAspectsJar(IClasspathEntry[] entries) throws JavaModelException {
        for (IClasspathEntry entry : entries) {
            if (isSpringAspectsEntry(entry)) {
                return true;
            } else if (entry.getEntryKind() == IClasspathEntry.CPE_CONTAINER) {
                if (hasSpringAspectsJar(extractEntriesFomContainer(entry))) {
                    return true;
                }
            }
        }
        return false;
    }

    private boolean isJarOnAspectPath(IClasspathEntry[] entries) throws JavaModelException {
        for (IClasspathEntry entry : entries) {
            if (isSpringAspectsEntry(entry)) {
                if (AspectJCorePreferences.isOnAspectpath(entry)) {
                    return true;
                }
            } else if (entry.getEntryKind() == IClasspathEntry.CPE_CONTAINER) {
                if (isJarOnAspectPath(extractEntriesFomContainer(entry))) {
                    return true;
                }
            }
        }
        return false;
    }

    private boolean hasAJNature() {
        return Utils.isAJProject(project);
    }

    private boolean isSpringAspectsEntry(IClasspathEntry entry) {
        String path = entry.getPath().toOSString();
        return SPRING_ASPECTS_JAR_PATTERN.matcher(path).matches() || SPRING_ASPECTS_PATTERN.matcher(path).matches();
    }

    private IClasspathEntry[] extractEntriesFomContainer(IClasspathEntry containerEntry) {
        try {
            IClasspathContainer container = JavaCore.getClasspathContainer(containerEntry.getPath(), jProject);
            return container.getClasspathEntries();
        } catch (JavaModelException e) {
            SpringCore.log(
                    "Error accessing classpath container " + containerEntry.getPath() + " from project " + project,
                    e);
            return new IClasspathEntry[0];
        }
    }

    private boolean isAJEditorDefault() {
        IEditorDescriptor desc = PlatformUI.getWorkbench().getEditorRegistry().getDefaultEditor(".java",
                ContentTypeManager.getInstance().getContentType(JavaCore.JAVA_SOURCE_CONTENT_TYPE));
        return desc.getId().equals(AspectJEditor.ASPECTJ_EDITOR_ID);
    }
}