plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/modulecore/util/JEEManifestDiscerner.java

/******************************************************************************
 * Copyright (c) 2009 Red Hat
 * 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:
 *    Rob Stryker - initial implementation
 ******************************************************************************/
package org.eclipse.jst.j2ee.internal.modulecore.util;

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

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.jst.common.internal.modulecore.util.ArchiveManifest;
import org.eclipse.jst.common.internal.modulecore.util.IJavaComponentDiscerner;
import org.eclipse.jst.common.internal.modulecore.util.ManifestUtilities;
import org.eclipse.jst.j2ee.project.EarUtilities;
import org.eclipse.wst.common.componentcore.ComponentCore;
import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualFile;
import org.eclipse.wst.common.componentcore.resources.IVirtualFolder;
import org.eclipse.wst.common.componentcore.resources.IVirtualReference;

/**
 * This class is meant to discover possible manifest entries for a parent / child combo.
 * This might be better implemented using flat virtual component model to make more 
 * accurate use of consumes, etc. But that can change later (as usual)
 */
public class JEEManifestDiscerner implements IJavaComponentDiscerner {

	public IProject[] findParentProjects(IProject child) {
		return EarUtilities.getReferencingEARProjects(child);
	}

	public IVirtualReference[] findPossibleManifestEntries(
			IProject parentProject, IProject childProject) {
		if( EarUtilities.isEARProject(parentProject)) {
			ArrayList<IVirtualReference> allPossible = findAllPossibleEntries(parentProject, childProject);
			IVirtualReference[] alreadyReferenced = findCurrentManifestEntries(parentProject, childProject, allPossible);
			allPossible.removeAll(Arrays.asList(alreadyReferenced));
			return allPossible.toArray(new IVirtualReference[allPossible.size()]);
		}
		return new IVirtualReference[]{};
	}
	
	public IVirtualReference[] findPossibleManifestEntries(
			IProject parentProject, IProject childProject, IVirtualReference[] currentEntries) {
		if( EarUtilities.isEARProject(parentProject)) {
			ArrayList<IVirtualReference> allPossible = findAllPossibleEntries(parentProject, childProject);
			allPossible.removeAll(Arrays.asList(currentEntries));
			return allPossible.toArray(new IVirtualReference[allPossible.size()]);
		}
		return new IVirtualReference[]{};
	}

	
	protected ArrayList<IVirtualReference> findAllPossibleEntries(IProject parentProject, IProject childProject) {
		IVirtualComponent ear = ComponentCore.createComponent(parentProject);
		IVirtualReference[] hardRefs = ear.getReferences();
		IVirtualReference[] actual_tmp = trimEarHardRefs(ear, childProject, hardRefs);
		IVirtualReference[] actual_clean = cleanHardRefs(actual_tmp, childProject, hardRefs);
		ArrayList<IVirtualReference> refs = new ArrayList<IVirtualReference>();
		refs.addAll(Arrays.asList(actual_clean));
		return refs;
	}
	
	/**
	 * Prune out unacceptable reference types
	 * @param childProject
	 * @param hardRefs
	 * @return
	 */
	private IVirtualReference[] trimEarHardRefs(IVirtualComponent ear, IProject childProject, IVirtualReference[] hardRefs) {
		String earLibDir = EarUtilities.getEARLibDir(ear);
		IPath earLibDirPath = null;
		if(earLibDir != null)
			earLibDirPath = new Path(earLibDir).makeRelative();		
		ArrayList<IVirtualReference> refs = new ArrayList<IVirtualReference>();
		// We have to prune out self-references 
		for( int i = 0; i < hardRefs.length; i++ ) {
			// This is actually hard to make sure we're not adding ourself
			if((hardRefs[i].getReferencedComponent().isBinary() 
					|| hardRefs[i].getDependencyType() == IVirtualReference.DEPENDENCY_TYPE_CONSUMES
					|| !hardRefs[i].getReferencedComponent().getProject().equals(childProject))
					&& hardRefs[i].getArchiveName().endsWith("jar")) { //$NON-NLS-1$ // Only jar's are legal in MANIFEST
				if(earLibDirPath == null || earLibDirPath.isEmpty() || !hardRefs[i].getRuntimePath().makeRelative().equals(earLibDirPath)) {// Jars in the EAR's library directory should not be added to the MANIFEST for EE5/EE6
					refs.add(hardRefs[i]);
				}
			}
		}
		return refs.toArray(new IVirtualReference[refs.size()]);
	}
	
	/**
	 * Make sure the runtime path + archiveName is what should go in the manifest file 
	 * if this reference is selected
	 * 
	 * @param original
	 * @return
	 */
	private IVirtualReference[] cleanHardRefs(IVirtualReference[] original, IProject childProject, IVirtualReference[] hardRefs) {
		IVirtualReference childProjectVirtualRef = null;
		for( int i = 0; i < hardRefs.length; i++ ) {
			if(hardRefs[i].getReferencedComponent().getProject().equals(childProject)) {
				childProjectVirtualRef = hardRefs[i];
				break;
			}
		}
	
		IVirtualReference[] newRefs = new IVirtualReference[original.length];
		for( int i = 0; i < newRefs.length; i++ ) {
			newRefs[i] = ComponentCore.createReference(original[i].getEnclosingComponent(), 
					original[i].getReferencedComponent(), calculateManifestRelativeRuntimePath(childProjectVirtualRef, original[i]));
			newRefs[i].setDependencyType(original[i].getDependencyType());
			newRefs[i].setArchiveName((new Path(original[i].getArchiveName())).lastSegment());
		}
		return newRefs;
	}
	
	public static IPath calculateManifestRelativeRuntimePath(IVirtualReference childProjectVirtualRef, IVirtualReference manifestEntryReference) {
		IPath manifestEntryPath = manifestEntryReference.getRuntimePath();
		// Return the manifestEntryReference's relative runtime path if the child project is at root level
		if(childProjectVirtualRef == null || childProjectVirtualRef.getRuntimePath().equals("/")) //$NON-NLS-1$
			return manifestEntryPath.makeRelative();
		IPath childProjectRuntimePath = childProjectVirtualRef.getRuntimePath();
		
		// Return an empty runtime path if the child project and manifest entry have same runtime path
		if(childProjectRuntimePath.equals(manifestEntryPath)) 
			return new Path(""); //$NON-NLS-1$
		
		String[] childProjectFolders = childProjectRuntimePath.segments();
		String[] manifestEntryFolders = manifestEntryPath.segments();
		int commonFolderCount = 0;
		for(int i = 0; i < childProjectFolders.length; i++) {
			if(i >= manifestEntryFolders.length || !childProjectFolders[i].equals(manifestEntryFolders[i]))
				break;
			commonFolderCount++;
		}
		final String upOneLevel = "../"; //$NON-NLS-1$
		String resultString = ""; //$NON-NLS-1$
		for(int i = 0; i < childProjectFolders.length - commonFolderCount; i++) {
			resultString += upOneLevel;
		}
		return new Path(resultString).append(manifestEntryPath.removeFirstSegments(commonFolderCount));
	}
	

	public IVirtualReference[] findCurrentManifestEntries(
			IProject parentProject, IProject childProject) {
		return findCurrentManifestEntries(parentProject, childProject, 
				findAllPossibleEntries(parentProject, childProject));
	}
	
	protected IVirtualReference[] findCurrentManifestEntries(
			IProject parentProject, IProject childProject, ArrayList<IVirtualReference> allPossibleEntries) {

		ArrayList<IVirtualReference> currentEntries = new ArrayList<IVirtualReference>();
		
		IFile manifestFile = getManifestFile(childProject);
		if(manifestFile != null) {
			ArchiveManifest manifest = ManifestUtilities.getManifest(manifestFile);
			List<String> entries = Arrays.asList(manifest.getClassPathTokenized());
			Iterator<IVirtualReference> i = allPossibleEntries.iterator();
			IVirtualReference currentI;
			
			// Add entries that are in the Manifest
			while(i.hasNext()) {
				currentI = i.next();
				String currentEntry = currentI.getRuntimePath().append((new Path(currentI.getArchiveName())).lastSegment()).toString();
				if(entries.contains(currentEntry))
					currentEntries.add(currentI);
			}
		}
		return currentEntries.toArray(new IVirtualReference[currentEntries.size()]);
	}

	protected IFile getManifestFile(IProject child) {
		IVirtualComponent root = ComponentCore.createComponent(child);
		IVirtualFolder rootFolder = root.getRootFolder();
		IVirtualFile vf = rootFolder.getFile(new Path("META-INF/MANIFEST.MF")); //$NON-NLS-1$
		if( vf.exists() )
			return vf.getUnderlyingFile();
		return null;
	}
	
	/**
	 * This is the usecase we'd like to deprecate, one day. One day.....
	 * (Though konstantin says NO)
	 * @param parentProject
	 * @param hardRefs
	 * @return
	 */
//	private IVirtualReference[] LEGACY_getClasspathDependencies(IProject parentProject, IVirtualReference[] hardRefs) {
//		ArrayList<IVirtualReference> retval = new ArrayList<IVirtualReference>();
//		ArrayList<IProject> seenProjects = new ArrayList<IProject>();
//		seenProjects.add(parentProject);
//		for( int i = 0; i < hardRefs.length; i++ ) {
//			if( hardRefs[i].getReferencedComponent() instanceof IClasspathDependencyProvider) {
//				// Already flagged classpaths
//				final IClasspathDependencyProvider j2eeComp = (IClasspathDependencyProvider) hardRefs[i].getReferencedComponent();
//				final IVirtualReference[] refs = j2eeComp.getJavaClasspathReferences();
//				for( int j = 0; j < refs.length; j++ ) {
//					if( !((IClasspathDependencyComponent)refs[j].getReferencedComponent()).isClassFolder()) {
//						// Clean this reference's runtime path
//						IPath newRuntimePath = refs[j].getRuntimePath();
//						if( newRuntimePath.toString().startsWith("../")) //$NON-NLS-1$
//							newRuntimePath = new Path(newRuntimePath.toString().substring(2)).makeRelative();
//						IVirtualReference tmp = ComponentCore.createReference(refs[j].getEnclosingComponent(), 
//								refs[j].getReferencedComponent(), newRuntimePath);
//						tmp.setDependencyType(refs[j].getDependencyType());
//						tmp.setArchiveName(refs[j].getArchiveName());
//						retval.add(tmp);
//					}
//				}
//			}
//		}
//		return retval.toArray(new IVirtualReference[retval.size()]);
//	}
//			// Now find *potential* entries
//			IProject cp = hardRefs[i].getReferencedComponent().getProject();
//			if( !seenProjects.contains(cp)) {
//				seenProjects.add(cp);
//				IJavaProjectLite lite = JavaCoreLite.create(cp);
//				try {
//					List<IClasspathEntry> entries = ClasspathDependencyUtil.getPotentialComponentClasspathDependencies(lite);
//					Iterator<IClasspathEntry> k = entries.iterator();
//					while(k.hasNext()) {
//						IVirtualReference tmp = LEGACY_convertClasspathEntry(cp, k.next());
//						if( tmp != null )
//							retval.add(tmp);
//					}
//				} catch( CoreException ce ) {}
//			}
//		}

	
//	
//	private IVirtualReference LEGACY_convertClasspathEntry(IProject project, IClasspathEntry entry) {
//		IVirtualComponent tmp = ComponentCore.createComponent(project);
//		final IPath entryLocation = ClasspathDependencyUtil.getEntryLocation(entry);
//		if(entryLocation != null && !ClasspathDependencyUtil.isClassFolderEntry(entry)) {
//            final IClasspathAttribute attrib = ClasspathDependencyUtil.checkForComponentDependencyAttribute(
//            		entry, DependencyAttributeType.CLASSPATH_COMPONENT_DEPENDENCY, false);
//            boolean isWebApp = J2EEProjectUtilities.isDynamicWebProject(project);
//            IPath runtimePath = ClasspathDependencyUtil.getRuntimePath(attrib, isWebApp, false);
//			String componentPath = VirtualArchiveComponent.CLASSPATHARCHIVETYPE
//				+ IPath.SEPARATOR + entryLocation.toPortableString();
//			IVirtualComponent entryComponent = new ClasspathDependencyVirtualComponent(
//					project, componentPath, false);
//			final IVirtualReference entryReference = ComponentCore.createReference(tmp, entryComponent, runtimePath);
//			((VirtualReference) entryReference).setDerived(true);
//			entryReference.setArchiveName(ClasspathDependencyUtil.getArchiveName(entry));
//			return entryReference;
//		}
//		return null;
//	}
	
}