ClasspathEmitter.java

/*******************************************************************************
 * Copyright (c) 2004, 2006
 * Thomas Hallgren, Kenneth Olwing, Mitch Sonies
 * Pontus Rydin, Nils Unden, Peer Torngren
 * The code, documentation and other materials contained herein have been
 * licensed under the Eclipse Public License - v 1.0 by the individual
 * copyright holders listed above, as Initial Contributors under such license.
 * The text of such license is available at www.eclipse.org.
 *******************************************************************************/
package org.eclipse.buckminster.jdt.internal;

import java.text.Format;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;

import org.eclipse.buckminster.core.build.PropertiesEmitter;
import org.eclipse.buckminster.core.helpers.ArrayUtils;
import org.eclipse.buckminster.jdt.Messages;
import org.eclipse.buckminster.runtime.Buckminster;
import org.eclipse.buckminster.runtime.BuckminsterException;
import org.eclipse.buckminster.runtime.Logger;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.AssertionFailedException;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.jdt.core.IClasspathContainer;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaModel;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.core.ClasspathEntry;

/**
 * A Builder that emits the fully resolved classpath of the current project.
 * 
 * @author Thomas Hallgren
 */
@SuppressWarnings("restriction")
public class ClasspathEmitter extends PropertiesEmitter {
	public static final String ARG_FORMAT_CLASSPATH = "format.classpath"; //$NON-NLS-1$

	public static final String ARG_TARGET = "target"; //$NON-NLS-1$

	/**
	 * Path separator. Defaults to setting of system property
	 * "path.separator"
	 */
	public static final String ARG_PATH_SEPARATOR = "path.separator"; //$NON-NLS-1$

	public static final Format FORMAT_CLASSPATH = new MessageFormat("bm.classpath"); //$NON-NLS-1$

	private static final String pathSeparator = System.getProperty("path.separator", ":"); //$NON-NLS-1$ //$NON-NLS-2$

	/**
	 * Obtains the classpath that has been declared for the current project. The
	 * classpath entries are resolved down to their absolute location in the
	 * local file system. And empty list will be returned if the given project
	 * is not represented by a <code>IJavaProject</code> in the java model.
	 * 
	 * @param project
	 *            The project for which the classpath should be resolved.
	 * @param target
	 *            The target for which the classpath should be resolved or null
	 *            if the current project classpath should be used.
	 * @return A list of absolute paths in the local file system.
	 * @throws CoreException
	 */
	public static List<IPath> finalClasspathResolve(IProject project, String target) throws CoreException {
		IJavaModel model = JavaCore.create(ResourcesPlugin.getWorkspace().getRoot());

		HashSet<IPath> seenPaths = new HashSet<IPath>();
		HashSet<String> seenProjects = new HashSet<String>();
		ArrayList<IPath> finalClasspath = new ArrayList<IPath>();

		appendPaths(model, project, target, finalClasspath, seenPaths, seenProjects, true);
		return finalClasspath;
	}

	/**
	 * Returns the default output folder relative to the project.
	 * 
	 * @param project
	 * @return The folder or <code>null</code> if not applicable.
	 * @throws CoreException
	 */
	public static IPath getDefaultOutputFolder(IProject project) throws CoreException {
		String projectName = project.getName();
		IJavaModel model = JavaCore.create(ResourcesPlugin.getWorkspace().getRoot());
		IJavaProject javaProject = model.getJavaProject(projectName);
		if (javaProject == null || !javaProject.exists())
			return null;

		return javaProject.getOutputLocation().removeFirstSegments(1);
	}

	private static void appendPaths(IJavaModel model, IProject project, String target, List<IPath> path, HashSet<IPath> seenPaths,
			HashSet<String> seenProjects, boolean atTop) throws CoreException {
		Logger log = Buckminster.getLogger();
		String projectName = project.getName();
		if (seenProjects.contains(projectName))
			return;
		seenProjects.add(projectName);
		log.debug("Emitting classpath for project %s...", projectName); //$NON-NLS-1$

		IJavaProject javaProject = model.getJavaProject(projectName);
		IClasspathEntry[] entries;
		if (javaProject == null || !javaProject.exists()) {
			// The project may still be a component that exports jar files.
			//
			BMClasspathContainer container = new BMClasspathContainer(project, target);
			entries = container.getClasspathEntries();
			log.debug(" not a java project, contains %d entries", Integer.valueOf(entries.length)); //$NON-NLS-1$
		} else {
			entries = (atTop && target != null) ? changeClasspathForTarget(javaProject, target) : javaProject.getResolvedClasspath(false);
			log.debug(" java project, contains %d entries", Integer.valueOf(entries.length)); //$NON-NLS-1$
		}

		for (IClasspathEntry entry : entries) {
			IPath entryPath;
			switch (entry.getEntryKind()) {
				case IClasspathEntry.CPE_LIBRARY:
					log.debug(" found library with path: %s", entry.getPath()); //$NON-NLS-1$
					if (!(atTop || entry.isExported())) {
						log.debug(" skipping path %s. It's neither at top nor exported", entry.getPath()); //$NON-NLS-1$
						continue;
					}

					entryPath = entry.getPath();
					break;
				case IClasspathEntry.CPE_SOURCE:
					entryPath = entry.getOutputLocation();
					if (entryPath == null) {
						// Uses default output location
						//
						IJavaProject proj = model.getJavaProject(entry.getPath().segment(0));
						if (proj == null)
							continue;
						entryPath = proj.getOutputLocation();
					}
					log.debug(" found source with path: %s", entryPath); //$NON-NLS-1$
					break;
				case IClasspathEntry.CPE_PROJECT:
					projectName = entry.getPath().segment(0);
					log.debug(" found project: %s", projectName); //$NON-NLS-1$
					if (!(atTop || entry.isExported())) {
						log.debug(" skipping project %s. It's neither at top nor exported", projectName); //$NON-NLS-1$
						continue;
					}

					IProject conProject = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
					appendPaths(model, conProject, null, path, seenPaths, seenProjects, false);
					continue;
				default:
					throw BuckminsterException.fromMessage(Messages.unexpected_classpath_entry_kind);
			}

			IResource folder = ResourcesPlugin.getWorkspace().getRoot().findMember(entryPath);
			if (folder != null) {
				log.debug(" path %s is inside workspace, switching to %s", entryPath, folder.getLocation()); //$NON-NLS-1$
				entryPath = folder.getLocation();
			}

			if (!seenPaths.contains(entryPath)) {
				seenPaths.add(entryPath);
				path.add(entryPath);
				log.debug(" path %s added", entryPath); //$NON-NLS-1$
			}
		}
	}

	/**
	 * This method obtains the raw classpath from the javaProject and scans it
	 * for BMClasspathContainer. The first one found is either kept if it
	 * corresponds to the target or replaced if not. All other
	 * BMClasspathContainers are removed. If no BMClasspathContainer was found,
	 * a new one that represents the target is added first in the list. All
	 * IClasspathEntry instances are then resolved.
	 * 
	 * @param javaProject
	 * @param target
	 * @return
	 * @throws JavaModelException
	 */
	private static IClasspathEntry[] changeClasspathForTarget(IJavaProject javaProject, String target) throws CoreException {
		boolean entriesChanged = false;
		boolean haveOtherBMCPs = false;
		boolean targetContainerInstalled = false;

		Logger log = Buckminster.getLogger();
		log.debug("Changing classpath for project %s into %s", javaProject.getProject().getName(), target); //$NON-NLS-1$
		IPath desiredContainer = BMClasspathContainer.PATH.append(target);
		IClasspathEntry[] rawEntries = javaProject.readRawClasspath();
		int top = rawEntries.length;
		for (int idx = 0; idx < top; ++idx) {
			IClasspathEntry rawEntry = rawEntries[idx];
			if (rawEntry.getEntryKind() == IClasspathEntry.CPE_CONTAINER) {
				IPath entryPath = rawEntry.getPath();
				if (BMClasspathContainer.PATH.isPrefixOf(entryPath)) {
					if (!targetContainerInstalled) {
						if (!desiredContainer.equals(entryPath)) {
							// This is not the desired container. Replace it.
							//
							rawEntries[idx] = JavaCore.newContainerEntry(desiredContainer);
							entriesChanged = true;
						}
						targetContainerInstalled = true;
					} else
						haveOtherBMCPs = true;
				}
			}
		}

		if (targetContainerInstalled) {
			if (haveOtherBMCPs) {
				// Remove other Buckminster containers
				//
				ArrayList<IClasspathEntry> newEntries = new ArrayList<IClasspathEntry>(top);
				for (int idx = 0; idx < top; ++idx) {
					IClasspathEntry rawEntry = rawEntries[idx];
					if (rawEntry.getEntryKind() != IClasspathEntry.CPE_CONTAINER || rawEntry.getPath().equals(desiredContainer))
						newEntries.add(rawEntry);
				}
				rawEntries = newEntries.toArray(new IClasspathEntry[newEntries.size()]);
				entriesChanged = true;
			}
		} else {
			rawEntries = ArrayUtils.appendFirst(rawEntries, new IClasspathEntry[] { JavaCore.newContainerEntry(desiredContainer) });
			entriesChanged = true;
		}

		log.debug(entriesChanged ? " changes detected" : " no changes detected"); //$NON-NLS-1$ //$NON-NLS-2$

		return entriesChanged ? getResolvedClasspath(javaProject, rawEntries) : javaProject.getResolvedClasspath(false);
	}

	private static IClasspathEntry[] getResolvedClasspath(IJavaProject project, IClasspathEntry[] entries) throws CoreException {
		ArrayList<IClasspathEntry> resolvedEntries = new ArrayList<IClasspathEntry>();
		for (IClasspathEntry rawEntry : entries) {
			switch (rawEntry.getEntryKind()) {
				case IClasspathEntry.CPE_VARIABLE:

					IClasspathEntry resolvedEntry = null;
					try {
						resolvedEntry = JavaCore.getResolvedClasspathEntry(rawEntry);
					} catch (AssertionFailedException e) {
					}
					if (resolvedEntry == null)
						throw new JavaModelException(ClasspathEntry.validateClasspathEntry(project, rawEntry, false, false));
					break;

				case IClasspathEntry.CPE_CONTAINER:
					IPath entryPath = rawEntry.getPath();
					IClasspathContainer container;
					if (BMClasspathContainer.PATH.isPrefixOf(entryPath))
						//
						// This one is probably not in the project classpath
						//
						container = new BMClasspathContainer(project.getProject(), entryPath.segmentCount() > 1 ? entryPath.lastSegment() : null);
					else
						container = JavaCore.getClasspathContainer(entryPath, project);

					if (container == null)
						throw new JavaModelException(ClasspathEntry.validateClasspathEntry(project, rawEntry, false, false));

					IClasspathEntry[] containerEntries = container.getClasspathEntries();
					if (containerEntries == null)
						continue;

					for (IClasspathEntry cEntry : containerEntries) {
						// if container is exported or restricted, then its
						// nested
						// entries must in turn be exported
						//
						cEntry = ((ClasspathEntry) cEntry).combineWith((ClasspathEntry) rawEntry);
						resolvedEntries.add(cEntry);
					}
					continue;
			}
			resolvedEntries.add(rawEntry);
		}
		return resolvedEntries.toArray(new IClasspathEntry[resolvedEntries.size()]);
	}

	@Override
	protected void addFormatters() {
		this.addFormat(ARG_FORMAT_CLASSPATH, FORMAT_CLASSPATH);
	}

	@Override
	protected void appendProperties() throws CoreException {
		IProject project = this.getProject();
		StringBuilder bld = new StringBuilder();
		String target = this.getArgument(ARG_TARGET);
		String pathSep = this.getArgument(ARG_PATH_SEPARATOR);
		if (pathSep == null)
			pathSep = pathSeparator;

		for (IPath location : finalClasspathResolve(project, target)) {
			if (bld.length() > 0)
				bld.append(pathSeparator);
			bld.append(this.formatPath(location));
		}
		this.addProperty(ARG_FORMAT_CLASSPATH, new String[] { project.getName(), target }, bld.toString());
	}
}