/*******************************************************************************
* Copyright (c) 2009 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.jst.common.internal.modulecore;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;
import org.eclipse.jst.common.frameworks.CommonFrameworksPlugin;
import org.eclipse.jst.common.jdt.internal.javalite.JavaLiteUtilities;
import org.eclipse.wst.common.componentcore.internal.ComponentResource;
import org.eclipse.wst.common.componentcore.internal.Property;
import org.eclipse.wst.common.componentcore.internal.StructureEdit;
import org.eclipse.wst.common.componentcore.internal.WorkbenchComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualReference;
public class SingleRootUtil {
public interface SingleRootCallback {
public boolean canValidate(IVirtualComponent vc);
public void validate(SingleRootUtil util, IVirtualComponent vc, IProject project, List resourceMaps);
}
/**
* Used to return immediately after the first error code is found.
*/
public static final int INCLUDE_FIRST_ERROR = 0x08;
/**
* Used to capture all status codes (error, warning, info)
*/
public static final int INCLUDE_ALL = 0x07;
/**
* Used to capture all error and warning status codes only.
*/
public static final int INCLUDE_ERRORS_AND_WARNINGS = 0x06;
/**
* Used to capture all error status codes only.
*/
public static final int INCLUDE_ERRORS = 0x04;
private static final int WARNINGS = 0x02;
private static final int INFO = 0x01;
private static final int CANCEL = 0x0;
private static final int GET_SINGLE_ROOT_CONTAINER = 0x09;
private static String USE_SINGLE_ROOT_PROPERTY = "useSingleRoot"; //$NON-NLS-1$
private IVirtualComponent aComponent;
private SingleRootCallback callback;
private List<IContainer> cachedSourceContainers;
private IContainer[] cachedOutputContainers;
private MultiStatus wrapperStatus;
private int VALIDATE_FLAG;
public SingleRootUtil(IVirtualComponent component) {
this(component, null);
}
public SingleRootUtil(IVirtualComponent component, SingleRootCallback callback) {
this.aComponent = component;
this.callback = callback;
}
/**
* Returns true if this module has a simple structure based on a
* single-root folder, and false otherwise.
*
* In a single-root structure, all files that are contained within the root folder
* are part of the module, and are already in the correct module structure. No
* module resources exist outside of this single folder.
*
* @return true if this module has a single-root structure, and
* false otherwise
*/
public boolean isSingleRoot() {
return validateSingleRoot(INCLUDE_FIRST_ERROR).getSeverity() != IStatus.ERROR;
}
/**
* Will attempt to return the IContainer that counts as the "single-root".
* If this module does not qualify as a "single-root" module, this
* method will return null. Otherwise it will return an IContainer
* that may be used as the single-root container.
*
* @return IContainer representing single-root container
*/
public IContainer getSingleRoot() {
IStatus status = validateSingleRoot(GET_SINGLE_ROOT_CONTAINER);
if (status.getSeverity() == IStatus.INFO) {
IStatus[] children = ((MultiStatus) status).getChildren();
ISingleRootStatus rootStatus = (ISingleRootStatus) children[0];
return rootStatus.getSingleRoot();
}
return null;
}
/**
* Validates whether the component module has a single-root structure.
* An IStatus with a severity of OK is returned for a valid single-root
* structure. A MultiStatus containing children of type ISingleRootStatus
* is returned if any status codes were captured during the validation.
* A MultiStatus with a severity of INFO or WARNING is returned for a valid
* single-root structure containing status codes with no severities of ERROR.
* A MultiStatus with a severity of ERROR means the component does not have a
* valid single-root structure.
*
* @param flag - indicates the status codes (by severity) to capture during
* the validation. The INLCUDE_ALL flag will also capture the
* single-root container if a single-root structure was found.
* Valid flags are:
* INCLUDE_ALL
* INCLUDE_ERRORS_AND_WARNINGS
* INCLUDE_ERRORS
* INCLUDE_FIRST_ERROR
*
* @return IStatus
*/
public IStatus validateSingleRoot(int flag) {
VALIDATE_FLAG = flag;
wrapperStatus = null;
StructureEdit edit = null;
try {
edit = StructureEdit.getStructureEditForRead(getProject());
if (edit == null || edit.getComponent() == null) {
reportStatus(ISingleRootStatus.NO_COMPONENT_FOUND);
return getStatus();
}
if (aComponent.isBinary()) {
reportStatus(ISingleRootStatus.BINARY_COMPONENT_FOUND);
return getStatus();
}
// 229650 - check to see if the property 'useSingleRoot' is defined.
Boolean useSingleRoot = getUseSingleRootProperty(edit);
if (useSingleRoot != null) {
//check if it was set to false
if (!useSingleRoot.booleanValue()) {
reportStatus(ISingleRootStatus.EXPLICITLY_DISABLED);
}
else {
reportStatus(ISingleRootStatus.SINGLE_ROOT_FORCED, aComponent.getRootFolder().getUnderlyingFolder());
}
return getStatus();
}
// if there are any consumed references, this is not single-root
if (hasConsumableReferences(aComponent)) {
reportStatus(ISingleRootStatus.CONSUMABLE_REFERENCES_FOUND);
if (VALIDATE_FLAG == CANCEL)
return getStatus();
}
// if there are any linked resources then this is not a single-root module
if (rootFoldersHaveLinkedContent()) {
reportStatus(ISingleRootStatus.LINKED_RESOURCES_FOUND);
if (VALIDATE_FLAG == CANCEL)
return getStatus();
}
List resourceMaps = edit.getComponent().getResources();
// If the list is empty, return false
if (resourceMaps.size() < 1) {
reportStatus(ISingleRootStatus.NO_RESOURCE_MAPS_FOUND);
return getStatus();
}
if (callback != null && callback.canValidate(aComponent)) {
callback.validate(this, aComponent, getProject(), resourceMaps);
}
if (VALIDATE_FLAG != CANCEL) {
validateProject(resourceMaps);
}
return getStatus();
} finally {
cachedOutputContainers = null;
cachedSourceContainers = null;
if (edit != null)
edit.dispose();
}
}
protected Boolean getUseSingleRootProperty(StructureEdit edit) {
WorkbenchComponent wbComp = edit.getComponent();
final List componentProperties = wbComp.getProperties();
if (componentProperties != null) {
final Iterator componentPropertiesIterator = componentProperties.iterator();
while (componentPropertiesIterator.hasNext()) {
Property wbProperty = (Property) componentPropertiesIterator.next();
if (USE_SINGLE_ROOT_PROPERTY.equals(wbProperty.getName())) {
return Boolean.valueOf(wbProperty.getValue());
}
}
}
return null;
}
protected boolean hasConsumableReferences(IVirtualComponent vc) {
IVirtualReference[] refComponents = vc.getReferences();
for (int i = 0; i < refComponents.length; i++) {
IVirtualReference reference = refComponents[i];
if (reference != null && reference.getDependencyType()==IVirtualReference.DEPENDENCY_TYPE_CONSUMES) {
return true;
}
}
return false;
}
private void validateProject(List resourceMaps) {
// Ensure there are only source folder component resource mappings to the root content folder
if (isRootResourceMapping(resourceMaps)) {
IContainer[] javaOutputFolders = getJavaOutputFolders();
// Verify only one java outputfolder
if (javaOutputFolders.length == 1) {
// By the time we get here we know: for any folders defined as source in the
// .component file that they are also java source folders.
if (!isSourceContainer(javaOutputFolders[0])) {
// The single output folder is NOT a source folder so this is single-rooted. Since the
// output folder (something like classes or bin) is not a source folder, JDT copies all files
// (including non Java files) to this folder, so every resource needed at runtime is located
// in a single directory.
reportStatus(ISingleRootStatus.SINGLE_ROOT_CONTAINER_FOUND, javaOutputFolders[0]);
return;
}
// Verify the java output folder is the same as one of the content roots
IPath javaOutputPath = getJavaOutputFolders()[0].getProjectRelativePath();
IContainer[] rootFolders = aComponent.getRootFolder().getUnderlyingFolders();
for (int i=0; i < rootFolders.length; i++) {
IPath compRootPath = rootFolders[i].getProjectRelativePath();
if (javaOutputPath.equals(compRootPath)) {
reportStatus(ISingleRootStatus.SINGLE_ROOT_CONTAINER_FOUND, aComponent.getRootFolder().getUnderlyingFolder());
return;
}
}
reportStatus(ISingleRootStatus.JAVA_OUTPUT_NOT_A_CONTENT_ROOT);
}
else {
reportStatus(ISingleRootStatus.JAVA_OUTPUT_GREATER_THAN_1);
}
}
}
public IContainer[] getJavaOutputFolders() {
if (cachedOutputContainers == null)
cachedOutputContainers = getJavaOutputFolders(aComponent);
return cachedOutputContainers;
}
public static IContainer[] getJavaOutputFolders(IVirtualComponent component) {
if (component == null)
return new IContainer[0];
List<IContainer> l = JavaLiteUtilities.getJavaOutputContainers(component);
return l.toArray(new IContainer[l.size()]);
}
/**
* Checks if the path argument is to a source container for the project.
*
* @param a workspace relative full path
* @return is path a source container?
*/
public boolean isSourceContainer(IContainer sourceContainer) {
if (cachedSourceContainers == null) {
cachedSourceContainers = getSourceContainers(aComponent);
}
return cachedSourceContainers.contains(sourceContainer);
}
public static List<IContainer> getSourceContainers(IVirtualComponent component) {
if (component == null)
Collections.emptyList();
return JavaLiteUtilities.getJavaSourceContainers(component);
}
/*
* This method returns true if the root folders of this component have any linked resources (folder or file);
* Otherwise false is returned.
*/
private boolean rootFoldersHaveLinkedContent() {
if (this.aComponent != null) {
final IContainer[] rootFolders = this.aComponent.getRootFolder().getUnderlyingFolders();
for (int i = 0; i < rootFolders.length; i++) {
try {
boolean hasLinkedContent = this.hasLinkedContent(rootFolders[i]);
if (hasLinkedContent) {
return true;
}
}
catch (CoreException coreEx) {
CommonFrameworksPlugin.logError(coreEx);
}
}
}
return false;
}
/*
* If the resource to check is a file then this method will return true if the file is linked. If the resource to
* check is a folder then this method will return true if it, any of its sub directories, or any file contained
* with-in this directory of any of it's sub directories are linked. Otherwise false is returned.
*/
private boolean hasLinkedContent(final IResource resourceToCheck) throws CoreException {
if ((resourceToCheck != null) && resourceToCheck.isAccessible()) {
// skip non-accessible files
if (resourceToCheck.isLinked()) {
return true;
}
switch (resourceToCheck.getType()) {
case IResource.FOLDER:
// recursively check sub directory contents
final IResource[] subDirContents = ((IFolder) resourceToCheck).members();
for (int i = 0; i < subDirContents.length; i++) {
if (hasLinkedContent(subDirContents[i])) {
return true;
}
}
break;
case IResource.FILE:
return resourceToCheck.isLinked();
default:
// skip as we only care about files and folders
break;
}
}
return false;
}
/**
* Ensure that any component resource mappings are for source folders and
* that they map to the root content folder
*
* @param resourceMaps
* @return boolean
*/
private boolean isRootResourceMapping(List resourceMaps) {
for (int i=0; i < resourceMaps.size(); i++) {
ComponentResource resourceMap = (ComponentResource) resourceMaps.get(i);
// Verify it maps to "/" for the content root
if (!isRootMapping(resourceMap)) {
reportStatus(ISingleRootStatus.RUNTIME_PATH_NOT_ROOT, resourceMap.getRuntimePath());
if (VALIDATE_FLAG == CANCEL) return false;
}
// verify it is also a src container
IPath sourcePath = resourceMap.getSourcePath();
IResource sourceResource = getProject().findMember(sourcePath);
if (sourceResource != null && sourceResource.exists()) {
if (sourceResource instanceof IContainer && !isSourceContainer((IContainer) sourceResource)) {
reportStatus(ISingleRootStatus.SOURCE_NOT_JAVA_CONTAINER, sourcePath);
}
}
else {
reportStatus(ISingleRootStatus.SOURCE_PATH_NOT_FOUND, sourcePath);
}
if (VALIDATE_FLAG == CANCEL) return false;
}
return true;
}
public boolean isRootMapping(ComponentResource map) {
// Verify it maps to "/" for the content root
if (map.getRuntimePath().equals(Path.ROOT))
return true;
return false;
}
public IProject getProject() {
return aComponent.getProject();
}
public void reportStatus(int code) {
reportStatus(code, null, null);
}
public void reportStatus(int code, IContainer container) {
reportStatus(code, null, container);
}
public void reportStatus(int code, IPath path) {
reportStatus(code, path, null);
}
public void reportStatus(int code, IPath path, IContainer container) {
ISingleRootStatus status = new SingleRootStatus(code, path, container);
if (status.getSeverity() == IStatus.ERROR) {
if ((VALIDATE_FLAG & INCLUDE_FIRST_ERROR) != 0) {
VALIDATE_FLAG = CANCEL;
addStatus(status);
}
else if ((VALIDATE_FLAG & INCLUDE_ERRORS) != 0) {
addStatus(status);
}
}
else if (status.getSeverity() == IStatus.WARNING && (VALIDATE_FLAG & WARNINGS) != 0) {
addStatus(status);
}
else if (status.getSeverity() == IStatus.INFO && (VALIDATE_FLAG & INFO) != 0) {
VALIDATE_FLAG = CANCEL;
addStatus(status);
}
}
public int getValidateFlag() {
return VALIDATE_FLAG;
}
public void setValidateFlag(int validateFlag) {
VALIDATE_FLAG = validateFlag;
}
public IStatus getStatus() {
if (wrapperStatus != null) {
return wrapperStatus;
}
return Status.OK_STATUS;
}
private void addStatus(ISingleRootStatus status) {
if (wrapperStatus == null) {
wrapperStatus = new MultiStatus(CommonFrameworksPlugin.PLUGIN_ID, 0, new IStatus[] { status }, null, null);
} else {
wrapperStatus.add(status);
}
}
}