/*******************************************************************************
* Copyright (c) 2001, 2005 IBM Corporation and others.
* 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:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jem.workbench.utility;
/*
* $RCSfile: JemProjectUtilities.java,v $ $Revision: 1.15 $ $Date: 2011/03/30 21:01:20 $
*/
import java.net.URL;
import java.util.*;
import org.eclipse.core.resources.*;
import org.eclipse.core.runtime.*;
import org.eclipse.jdt.core.*;
import org.eclipse.jem.internal.plugin.JavaEMFNature;
import org.eclipse.jem.java.JavaClass;
import org.eclipse.jem.java.JavaRefFactory;
import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
import org.eclipse.jem.util.emf.workbench.WorkbenchResourceHelperBase;
import org.eclipse.jem.util.emf.workbench.nature.EMFNature;
import org.eclipse.jem.util.plugin.JEMUtilPlugin;
/**
* Project Utilities for JEM and Java.
*
* @since 1.1.0
*/
public class JemProjectUtilities extends ProjectUtilities {
private JemProjectUtilities(){
}
/**
* The nature id for JEM Nature.
*
* @since 1.1.0
*/
public static final String JEM_EMF_NatureID = IJavaEMFNature.NATURE_ID;
/**
* Get the EMF nature for JEM for the project.
* @param project
* @param addNature <code>true</code> if add the nature to the project if not set. <code>false</code> if don't add nature if not already on project.
* @return the EMFNature or <code>null</code> if not found and addNature was <code>false</code> or it was not a java project.
* @throws CoreException
*
* @since 1.1.0
*/
public static EMFNature getJEM_EMF_Nature(IProject project, boolean addNature) throws CoreException {
return addNature ? JavaEMFNature.createRuntime(project) : JavaEMFNature.getRuntime(project);
}
/**
* Get the JavaClass from an IFile.
* @param aFile
* @return
*
* @since 1.1.0
*/
public static JavaClass getJavaClass(IFile aFile) {
if (aFile == null)
return null;
IProject project = aFile.getProject();
List folders = getSourceContainers(project);
folders.addAll(getLibraryContainers(project));
IContainer folder = null;
IPath folderPath, filePath, javaPath;
filePath = aFile.getProjectRelativePath();
for (int i = 0; i < folders.size(); i++) {
folder = (IContainer) folders.get(i);
folderPath = folder.getProjectRelativePath();
int segments = filePath.matchingFirstSegments(folderPath);
if (segments > 0) {
javaPath = filePath.removeFirstSegments(segments);
javaPath = javaPath.removeFileExtension();
String qualifiedName = javaPath.toString().replace('/', '.');
return (JavaClass) JavaRefFactory.eINSTANCE.reflectType(qualifiedName, WorkbenchResourceHelperBase.getResourceSet(project));
}
}
return null;
}
/**
* Get source containers for the project.
*
* @param p
* project
* @return list of source containers.
*
* @since 1.0.0
*/
public static List getSourceContainers(IProject p) {
try {
List sourceContainers = new ArrayList();
List sourcePaths = getSourcePaths(p);
if (sourcePaths != null && !sourcePaths.isEmpty()) {
for (int i = 0; i < sourcePaths.size(); i++) {
IPath path = (IPath) sourcePaths.get(i);
if (path.isEmpty())
sourceContainers.add(p);
else
sourceContainers.add(p.getFolder(path));
}
}
return sourceContainers;
} catch (IllegalArgumentException ex) {
return Collections.EMPTY_LIST;
}
}
protected static List getSourcePaths(IProject p) {
IJavaProject javaProj = getJavaProject(p);
if (javaProj == null)
return null;
IClasspathEntry[] cp = null;
try {
cp = javaProj.getRawClasspath();
} catch (JavaModelException ex) {
JEMUtilPlugin.getLogger().logError(ex);
return null;
}
List sourcePaths = new ArrayList();
for (int i = 0; i < cp.length; i++) {
if (cp[i].getEntryKind() == IClasspathEntry.CPE_SOURCE) {
sourcePaths.add(cp[i].getPath().removeFirstSegments(1));
}
}
return sourcePaths;
}
/**
* Return list of IContainers that are Libraries in the classpath.
*
* @param p
* project
* @return list of library IContainers.
*
* @since 1.0.0
*/
public static List getLibraryContainers(IProject p) {
try {
List libraryContainers = new ArrayList();
List libraryPaths = getlibraryPaths(p);
if (libraryPaths != null && !libraryPaths.isEmpty()) {
for (int i = 0; i < libraryPaths.size(); i++) {
IPath path = (IPath) libraryPaths.get(i);
if (path.isEmpty())
libraryContainers.add(p);
else
libraryContainers.add(p.getFolder(path));
}
}
return libraryContainers;
} catch (IllegalArgumentException ex) {
return Collections.EMPTY_LIST;
}
}
protected static List getlibraryPaths(IProject p) {
IJavaProject javaProj = getJavaProject(p);
if (javaProj == null)
return null;
IClasspathEntry[] cp = null;
try {
cp = javaProj.getRawClasspath();
} catch (JavaModelException ex) {
JEMUtilPlugin.getLogger().logError(ex);
return null;
}
List libraryPaths = new ArrayList();
for (int i = 0; i < cp.length; i++) {
if (cp[i].getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
libraryPaths.add(cp[i].getPath().removeFirstSegments(1));
}
}
return libraryPaths;
}
/**
* Get the java project nature for the given project.
*
* @param p
* project
* @return the java project nature for the project or <code>null</code> if not a java project.
*
* @since 1.0.0
*/
public static IJavaProject getJavaProject(IProject p) {
if (p != null)
{
try {
return (IJavaProject) p.getNature(JavaCore.NATURE_ID);
} catch (CoreException ignore) {
return null;
}
}
return null;
}
/**
* Touch classpath. It simply takes the classpath and sets it back in.
*
* @param javaProject
* @throws JavaModelException
*
* @since 1.0.0
*/
public static void updateClasspath(IJavaProject javaProject) throws JavaModelException {
if (javaProject != null)
javaProject.setRawClasspath(javaProject.getRawClasspath(), new NullProgressMonitor());
}
/**
* Return the location of the binary output files for the JavaProject.
*
* @param p
* project
* @return path to binary output folder or <code>null</code> if not java project or other problem.
*
* @since 1.0.0
*/
public static IPath getJavaProjectOutputLocation(IProject p) {
try {
IJavaProject javaProj = getJavaProject(p);
if (javaProj == null)
return null;
if (!javaProj.isOpen())
javaProj.open(null);
return javaProj.readOutputLocation();
} catch (JavaModelException e) {
return null;
}
}
/**
* Get the project's binary output container.
*
* @param p
* project
* @return project's output container or <code>null</code> if not java project or some other error.
*
* @since 1.0.0
*/
public static IContainer getJavaProjectOutputContainer(IProject p) {
IPath path = getJavaProjectOutputLocation(p);
if (path == null)
return null;
if (path.segmentCount() == 1)
return p;
return p.getFolder(path.removeFirstSegments(1));
}
/**
* Get the binary output absolute (local file system) path.
*
* @param p
* project
* @return project's output path or <code>null</code> if not java project or some other error.
*
* @since 1.0.0
*/
public static IPath getJavaProjectOutputAbsoluteLocation(IProject p) {
IContainer container = getJavaProjectOutputContainer(p);
if (container != null)
return container.getLocation();
return null;
}
/**
* Get the JDT JavaModel.
*
* @return JDT's JavaModel
*
* @since 1.0.0
*/
public static IJavaModel getJavaModel() {
return JavaCore.create(ResourcesPlugin.getWorkspace().getRoot());
}
/**
* Get all source package fragment roots.
*
* @param javaProj
* @return source package fragment roots
* @throws JavaModelException
*
* @since 1.0.0
*/
public static List getSourcePackageFragmentRoots(IJavaProject javaProj) throws JavaModelException {
List result = new ArrayList();
IPackageFragmentRoot[] roots = javaProj.getPackageFragmentRoots();
for (int i = 0; i < roots.length; i++) {
IPackageFragmentRoot root = roots[i];
if (root.getKind() == IPackageFragmentRoot.K_SOURCE)
result.add(root);
}
return result;
}
/**
* Remove the resource from the classpath
*
* @param p
* project
* @param res
* resource
* @throws JavaModelException
*
* @since 1.0.0
*/
public static void removeFromJavaClassPath(IProject p, IResource res) throws JavaModelException {
IClasspathEntry entry = JavaCore.newLibraryEntry(res.getFullPath(), null, null);
removeFromJavaClassPath(p, entry);
}
/**
* Remove the path from the classpath
*
* @param p
* project
* @param path
* path to remove
* @throws JavaModelException
*
* @since 1.0.0
*/
public static void removeFromJavaClassPath(IProject p, IPath path) throws JavaModelException {
org.eclipse.core.resources.IFile f = p.getFile(path);
removeFromJavaClassPath(p, f);
}
/**
* Remove the classpath entry from the project's classpath.
*
* @param p
* @param entry
* @throws JavaModelException
*
* @since 1.0.0
*/
public static void removeFromJavaClassPath(IProject p, IClasspathEntry entry) throws JavaModelException {
IJavaProject javaProject = null;
try {
javaProject = (IJavaProject) p.getNature(JavaCore.NATURE_ID);
} catch (CoreException ignore) {
}
if (javaProject != null) {
IClasspathEntry[] classpath = javaProject.getRawClasspath();
javaProject.setRawClasspath(primRemoveFromJavaClassPath(classpath, entry), new NullProgressMonitor());
}
}
/**
* Remove the list of entries from the classpath of the project.
*
* @param p
* project
* @param entries
* list of IClassPathEntry's
* @throws JavaModelException
*
* @since 1.0.0
*/
public static void removeFromJavaClassPath(IProject p, List entries) throws JavaModelException {
IJavaProject javaProject = null;
try {
javaProject = (IJavaProject) p.getNature(JavaCore.NATURE_ID);
} catch (CoreException ignore) {
}
if (javaProject != null) {
IClasspathEntry[] classpath = javaProject.getRawClasspath();
javaProject.setRawClasspath(primRemoveFromJavaClassPath(classpath, entries), new NullProgressMonitor());
}
}
protected static IClasspathEntry[] primRemoveFromJavaClassPath(IClasspathEntry[] classpath, IClasspathEntry entry) throws JavaModelException {
List result = new ArrayList();
boolean didRemove = false;
for (int i = 0; i < classpath.length; i++) {
IClasspathEntry cpEntry = classpath[i];
if (!entry.getPath().equals(classpath[i].getPath()))
result.add(cpEntry);
else
didRemove = true;
}
if (!didRemove)
return classpath;
return (IClasspathEntry[]) result.toArray(new IClasspathEntry[result.size()]);
}
protected static IClasspathEntry[] primRemoveFromJavaClassPath(IClasspathEntry[] classpath, List entries) throws JavaModelException {
List arrayList = Arrays.asList(classpath);
List removeable = new ArrayList(arrayList);
IClasspathEntry entry;
boolean didRemove = false;
int size = entries.size();
for (int i = 0; i < size; i++) {
entry = (IClasspathEntry) entries.get(i);
for (int j = 0; j < classpath.length; j++) {
IClasspathEntry cpEntry = classpath[j];
if (entry.getPath().equals(classpath[j].getPath())) {
if (removeable.remove(cpEntry))
didRemove = true;
}
}
}
if (!didRemove)
return classpath;
return (IClasspathEntry[]) removeable.toArray(new IClasspathEntry[removeable.size()]);
}
/**
* Get the classpath as an array or URL's.
*
* @param javaProject
* @return array of URL's or <code>null</code> if javaProject was <code>null</code>.
*
* @since 1.0.0
*/
public static URL[] getClasspathAsURLArray(IJavaProject javaProject) {
if (javaProject == null)
return null;
Set visited = new HashSet();
List urls = new ArrayList(20);
collectClasspathURLs(javaProject, urls, visited, true);
URL[] result = new URL[urls.size()];
urls.toArray(result);
return result;
}
private static void collectClasspathURLs(IJavaProject javaProject, List urls, Set visited, boolean isFirstProject) {
if (visited.contains(javaProject))
return;
visited.add(javaProject);
IPath outPath = getJavaProjectOutputAbsoluteLocation(javaProject.getProject());
outPath = outPath.addTrailingSeparator();
URL out = ProjectUtilities.createFileURL(outPath);
urls.add(out);
IClasspathEntry[] entries = null;
try {
entries = javaProject.getResolvedClasspath(true);
} catch (JavaModelException e) {
return;
}
IClasspathEntry entry;
for (int i = 0; i < entries.length; i++) {
entry = entries[i];
switch (entry.getEntryKind()) {
case IClasspathEntry.CPE_LIBRARY:
case IClasspathEntry.CPE_CONTAINER:
case IClasspathEntry.CPE_VARIABLE:
collectClasspathEntryURL(entry, urls);
break;
case IClasspathEntry.CPE_PROJECT: {
if (isFirstProject || entry.isExported())
collectClasspathURLs(getJavaProject(entry), urls, visited, false);
break;
}
}
}
}
private static void collectClasspathEntryURL(IClasspathEntry entry, List urls) {
IPath path = entry.getPath();
if (null == path.getDevice()) {
// workspace resource - is the IPath a file, folder, or a class folder whose location is the project root?
if(path.segmentCount() == 1) {
// It's a class folder whose location is the project root
path = ResourcesPlugin.getWorkspace().getRoot().getProject(path.lastSegment()).getLocation();
}
else {
// It's a file or folder - capture it's absolute location
IFile jarFile = ResourcesPlugin.getWorkspace().getRoot().getFile(path);
if(jarFile.exists()){
path = jarFile.getLocation();
}
}
}
URL url = ProjectUtilities.createFileURL(path);
if (url != null)
urls.add(url);
}
private static IJavaProject getJavaProject(IClasspathEntry entry) {
IProject proj = ResourcesPlugin.getWorkspace().getRoot().getProject(entry.getPath().segment(0));
if (proj != null)
return getJavaProject(proj);
return null;
}
/**
* Is this project a binary project.
* <p>
* Typically a Java project is considered binary if it does not have a source entry in the classpath.
*
* @param project
* Project to test
* @return <code>true</code> if project is a binary project.
*/
public static boolean isBinaryProject(IProject aProject) {
IJavaProject javaProj = getJavaProject(aProject);
if (javaProj == null)
return false;
IClasspathEntry[] entries = null;
entries = javaProj.readRawClasspath();
for (int i = 0; i < entries.length; i++) {
IClasspathEntry entry = entries[i];
if (entry.getEntryKind() == IClasspathEntry.CPE_SOURCE)
return false;
}
return true;
}
/**
* Append to java class path.
* <p>
* Append a list of IClasspathEntry's to the build path of the passed project. Updated to remove existing occurrences of the passed entries before
* appending.
* </p>
*
* @param p
* project
* @param appendClasspathEntries
* list of entries
* @throws JavaModelException
*
* @since 1.0.0
*/
public static void appendJavaClassPath(IProject p, List appendClasspathEntries) throws JavaModelException {
IJavaProject javaProject = null;
try {
javaProject = (IJavaProject) p.getNature(JavaCore.NATURE_ID);
} catch (CoreException ignore) {
}
if (javaProject != null) {
IClasspathEntry[] classpath = javaProject.getRawClasspath();
List newPathList = new ArrayList(classpath.length);
for (int i = 0; i < classpath.length; i++) {
IClasspathEntry entry = classpath[i];
// Skip entries which are in the append list
if (appendClasspathEntries.indexOf(entry) < 0)
newPathList.add(entry);
}
newPathList.addAll(appendClasspathEntries);
IClasspathEntry[] newClasspath = (IClasspathEntry[]) newPathList.toArray(new IClasspathEntry[newPathList.size()]);
javaProject.setRawClasspath(newClasspath, new NullProgressMonitor());
}
}
/**
* Append classpath entry.
* <p>
* Append one IClasspathEntry to the build path of the passed project. If a classpath entry having the same path as the parameter already exists,
* then does nothing.
* </p>
*
* @param p
* Project
* @param newEntry
* Entry
* @throws JavaModelException
*
* @since 1.0.0
*/
public static void appendJavaClassPath(IProject p, IClasspathEntry newEntry) throws JavaModelException {
IJavaProject javaProject = getJavaProject(p);
if (javaProject == null)
return;
IClasspathEntry[] classpath = javaProject.getRawClasspath();
List newPathList = new ArrayList(classpath.length);
for (int i = 0; i < classpath.length; i++) {
IClasspathEntry entry = classpath[i];
// fix dup class path entry for .JETEmitter project
// Skip the entry to be added if it already exists
if (Platform.getOS().equals(Platform.OS_WIN32)) {
if (!entry.getPath().toString().equalsIgnoreCase(newEntry.getPath().toString()))
newPathList.add(entry);
else
return;
} else {
if (!entry.getPath().equals(newEntry.getPath()))
newPathList.add(entry);
else
return;
}
}
newPathList.add(newEntry);
IClasspathEntry[] newClasspath = (IClasspathEntry[]) newPathList.toArray(new IClasspathEntry[newPathList.size()]);
javaProject.setRawClasspath(newClasspath, new NullProgressMonitor());
}
/**
* Return the source path matching the parameter; if the parameter is null, or if the source folder is not on the classpath, return the first
* source path on the classpath
*
* @param p
* project
* @param defaultSourceName
* source folder to find if on classpath, or if <code>null</code> the first folder
* @return path searched for or <code>null</code> if not java project or some other problem.
*
* @since 1.0.0
*/
public static IPath getSourcePathOrFirst(IProject p, String defaultSourceName) {
IJavaProject javaProj = getJavaProject(p);
if (javaProj == null)
return null;
IClasspathEntry[] cp = null;
try {
cp = javaProj.getRawClasspath();
} catch (JavaModelException ex) {
JEMUtilPlugin.getLogger().logError(ex);
return null;
}
IClasspathEntry firstSource = null;
IPath defaultSourcePath = null;
if (defaultSourceName != null)
defaultSourcePath = ProjectUtilities.createPath(p, defaultSourceName);
for (int i = 0; i < cp.length; i++) {
if (cp[i].getEntryKind() == IClasspathEntry.CPE_SOURCE) {
if (firstSource == null) {
firstSource = cp[i];
if (defaultSourcePath == null)
break;
}
if (cp[i].getPath().equals(defaultSourcePath))
return defaultSourcePath.removeFirstSegments(1);
}
}
if (firstSource == null)
return null;
if (firstSource.getPath().segment(0).equals(p.getName()))
return firstSource.getPath().removeFirstSegments(1);
return null;
}
/**
* Hack to force a reload of the .classpath file
*
* @param project
* project to reload
* @since 1.0.0
*/
public static void forceClasspathReload(IProject project) throws JavaModelException {
IJavaProject javaProj = getJavaProject(project);
if (javaProj != null) {
IClasspathEntry[] entries = javaProj.readRawClasspath();
if (entries != null) {
IPath output = javaProj.readOutputLocation();
if (output != null)
javaProj.setRawClasspath(entries, output, null);
}
}
}
/**
* Get the paths of all of the local jars in the classpath for the project. It does not recurse into referenced projects.
*
* @param proj
* project to search (should be a java project).
* @return A list of IPath, where each entry is a project relative path to a JAR contained in the project.
*/
public static List getLocalJARPathsFromClasspath(IProject proj) {
IJavaProject javaProj = getJavaProject(proj);
if (javaProj == null)
return null;
IPath projectPath = proj.getFullPath();
List result = new ArrayList();
IClasspathEntry[] entries = javaProj.readRawClasspath();
for (int i = 0; i < entries.length; i++) {
IClasspathEntry entry = entries[i];
if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
IPath path = entry.getPath();
int segments = path.matchingFirstSegments(projectPath);
if (segments > 0)
result.add(path.removeFirstSegments(segments));
}
}
return result;
}
/**
* Return the source folder matching the parameter; if the parameter is null, or if the source folder is not on the classpath, return the first
* source folder on the classpath
*
* @param p
* project
* @param defaultSourceName
* source folder to find if on classpath, or if <code>null</code> the first folder
* @return container searched for or <code>null</code> if not java project or some other problem.
*
* @since 1.0.0
*/
public static IContainer getSourceFolderOrFirst(IProject p, String defaultSourceName) {
try {
IPath sourcePath = getSourcePathOrFirst(p, defaultSourceName);
if (sourcePath == null)
return null;
else if (sourcePath.isEmpty())
return p;
else
return p.getFolder(sourcePath);
} catch (IllegalArgumentException ex) {
return null;
}
}
/**
* Returns a list of IFolder that represents each source folder in a java project
*
* @deprecated Use {@link #getSourceContainers(IProject)}because the project itself might be a source container
*
* @param p
* project
* @return
*
* @since 1.0.0
*/
public static List getSourceFolders(IProject p) {
try {
List sourceFolders = new ArrayList();
List sourcePaths = getSourcePaths(p);
if (sourcePaths != null && !sourcePaths.isEmpty()) {
for (int i = 0; i < sourcePaths.size(); i++) {
IPath path = (IPath) sourcePaths.get(i);
if (!path.isEmpty())
sourceFolders.add(p.getFolder(path));
}
}
return sourceFolders;
} catch (IllegalArgumentException ex) {
return Collections.EMPTY_LIST;
}
}
}