path: root/jsf/plugins/org.eclipse.jst.jsf.core/src/org/eclipse/jst/jsf/taglibprocessing/attributevalues/JavaClassType.java

/*******************************************************************************
 * Copyright (c) 2006 Oracle Corporation.
 * 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:
 *    Gerry Kessler/Oracle - initial API and implementation
 *    
 ********************************************************************************/
package org.eclipse.jst.jsf.taglibprocessing.attributevalues;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jdt.core.Flags;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.ITypeHierarchy;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.search.IJavaSearchConstants;
import org.eclipse.jdt.core.search.IJavaSearchScope;
import org.eclipse.jdt.core.search.SearchEngine;
import org.eclipse.jdt.core.search.SearchMatch;
import org.eclipse.jdt.core.search.SearchParticipant;
import org.eclipse.jdt.core.search.SearchPattern;
import org.eclipse.jdt.core.search.SearchRequestor;
import org.eclipse.jst.jsf.metadataprocessors.features.IPossibleValues;
import org.eclipse.jst.jsf.metadataprocessors.features.IValidValues;
import org.eclipse.jst.jsf.metadataprocessors.features.PossibleValue;
import org.eclipse.jst.jsf.metadataprocessors.features.ValidationMessage;

/**
 * Provides possible values and validates attribute values that should be fully qualified Java types.
 * A type can be verified against multiple "valid-interfaces" and/or a "valid-superclass" from meta-data.
 * Code checks to ensure the class can be instantiated (i.e. not abstract, anonymous or inner class)
 * Search is scoped to within the current project only. 
 * 
 * (Until https://bugs.eclipse.org/bugs/show_bug.cgi?id=142044 is fixed, only the first found will be used)
 * 
 * <p><b>Provisional API - subject to change</b></p>
 * @author Gerry Kessler - Oracle
 *
 */
public class JavaClassType extends ObjectType implements IPossibleValues, IValidValues{
	/**
	 * Trait name for valid interfaces
	 */
	public static final String POSSIBLE_VALUES_INTERFACES_PROP_NAME = "valid-interfaces"; //$NON-NLS-1$
	/**
	 * Trait name for valid superclass
	 */
	public static final String POSSIBLE_VALUES_SUPERCLASS_PROP_NAME = "valid-superclass"; //$NON-NLS-1$
	
	private List validationMsgs;
	
	/* (non-Javadoc)
	 * @see org.eclipse.jst.jsf.metadataprocessors.features.IPossibleValues#getPossibleValues()
	 */
	public List getPossibleValues() {
		List results = getTypes();
		if (results != null && !results.isEmpty()){
			
			Set vals = new HashSet(results.size());
			Set checkedTypes = new HashSet();
			for (Iterator it = results.iterator();it.hasNext();){
				SearchMatch match = (SearchMatch)it.next();
				IType res = (IType)match.getElement();
				addValidSubClasses(res, vals, checkedTypes);					
			}
			return createPossibleValues(vals);
		}						
		return new ArrayList(0);
	}
	
	private List createPossibleValues(Set vals) {
		List list = new ArrayList(vals.size());
		Iterator it = vals.iterator();
		while(it.hasNext()){
			IJavaElement elem = (IJavaElement)it.next();
			list.add(createPossibleValue(elem));
		}
		return list;
	}

	private void addValidSubClasses(IType res, Set vals, Set checkedTypes) {

		try {
			//check to see if we have already checked the hiearchy
			if (checkedTypes.contains(res))
				return;
						
			//should we add itself?
			if (isInnerOrAnonymousClass(res))
				return;
			if (!isAbstractClass(res))
				vals.add(res);  //since it is a set, dupes will not be added
			

			ITypeHierarchy hierarchy = res.newTypeHierarchy(getJavaProject(), null);			
			IType[] subclasses = hierarchy.getSubclasses(res);
			checkedTypes.add(res);
			for (int i=0;i<subclasses.length;i++){
				addValidSubClasses(subclasses[i], vals, checkedTypes);
			}
		} catch (JavaModelException e) {
			//ignore
		}
	}

	private List getTypes(){
		IJavaProject jp = getJavaProject();
		if (jp == null)
			return null;
		
		List elems = new ArrayList();
		elems.addAll(getInterfaces(jp));
		IType sc = getSuperClass(jp);
		if (sc != null)
			elems.add(sc);
			
		if (elems.size() > 0){				
			SearchRequestor requestor = new Searcher();
			SearchEngine engine = new SearchEngine();
			
			IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[]{jp});//, IJavaSearchScope.SOURCES | IJavaSearchScope.APPLICATION_LIBRARIES | IJavaSearchScope.);
			SearchPattern combined = SearchPattern.createPattern((IJavaElement)elems.get(0), IJavaSearchConstants.IMPLEMENTORS, 0);

//			 Until this bug is fixed, stub it out...  only the first interface/superclass will be used.
//							https://bugs.eclipse.org/bugs/show_bug.cgi?id=142044
//							for(int i=1;i<elems.size();i++){
//								final SearchPattern other = SearchPattern.createPattern((IJavaElement)elems.get(i), IJavaSearchConstants.IMPLEMENTORS, 0);
//								combined = SearchPattern.createAndPattern(combined, other);
//							}
			
			try {
				engine.search(combined, new SearchParticipant[] {SearchEngine.getDefaultSearchParticipant()}, scope, requestor, null);
				
			} catch (CoreException e) {
				//ignore
			}

			return ((Searcher)requestor).getResults();	
		}

		return Collections.EMPTY_LIST;
	}
	
    private IJavaProject getJavaProject()
    {
        IProject proj = getProject2();
        if (proj != null) { return JavaCore.create(proj); }
        return null;
    }

	private List getInterfaces(IJavaProject jp) {
		List ret = new ArrayList();
		List propVals = getInterfaceNames();		
		
		for (Iterator it = propVals.iterator();it.hasNext();){
			String propVal = (String)it.next();
			IType interfase = null;
			try {
				interfase = findType(jp, propVal);
				if (interfase != null){
					ret.add(interfase);
				}
			} catch (JavaModelException e) {
                // suppress and fall-through to return empty list
			}

		}
		return ret;
	}
	
	private IType getSuperClass(IJavaProject jp){
		IType superclass = null;
		try {
			String sc = getSuperClassName();
			if (sc != null && !sc.trim().equals("")){ //$NON-NLS-1$
				superclass = findType(jp, sc );
				if (superclass != null){
					return superclass;
				}
			}
		} catch (JavaModelException e) {
			//ignore
		}
		return null;
	}
	
	private PossibleValue createPossibleValue(IJavaElement val) {
		return new PossibleValue(((IType)val).getFullyQualifiedName());		
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jst.jsf.metadataprocessors.features.IValidValues#getValidationMessages()
	 */
	public List getValidationMessages() {
		if (validationMsgs == null){
			validationMsgs = new ArrayList();			
		}
		return validationMsgs;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jst.jsf.metadataprocessors.features.IValidValues#isValidValue(java.lang.String)
	 */
	public boolean isValidValue(String value) {
		if (value == null || value.trim().equals("")){ //$NON-NLS-1$
			getValidationMessages().add(new ValidationMessage(Messages.JavaClassType_invalid_type));
			return false;
		}
		IJavaProject jp = getJavaProject();
		if (jp == null)
			return false;
		
		//first verify that the value specified is a resolvable type
		IType type = getTypeForValue(jp, value);
		if (type != null){			
			//ensure that it is not abstract or anonymous
			if (!isInnerOrAnonymousClass(type) && !isAbstractClass(type)){
				//now verify that it meets the criteria
				ITypeHierarchy hierarchy;
				try {
					hierarchy = type.newTypeHierarchy(jp, null);
				} catch (JavaModelException e) {
					return false;
				}
						
				//check that all interfaces
				List<String> interfaceNames = getInterfaceNames();
				for (Iterator<String> it=interfaceNames.iterator();it.hasNext();){
					//check that all interfaces are satisfied by type
					IType interfase = getTypeForValue(jp, it.next());
					if (interfase == null){
						addNewValidationMessage(Messages.JavaClassType_not_found);
						return false;
					}
					else if (! containsType(hierarchy.getAllSupertypes(type), interfase)){
						addNewValidationMessage(Messages.JavaClassType_not_found);
						return false;
					}
				}
				//interfaces have been satisfied now check the superclass if specified				
				IType superClass = getSuperClass(jp); 
				if (superClass != null && superClass.equals(type))
					return true;
				else if (superClass != null && !containsType(hierarchy.getAllSuperclasses(type), superClass )){
					addNewValidationMessage(Messages.JavaClassType_not_found);
					return false;
				}
				return true;
//				List results = getTypes();
//				if (!results.isEmpty()){					
//					for (Iterator it = results.iterator();it.hasNext();){
//						SearchMatch match = (SearchMatch)it.next();
//						IType res = (IType)match.getElement();
//						if (!isInnerOrAnonymousClass(res) ){
//							//if this is the class, then optimize to reduce expense of creating hierarchy
//							if (!isAbstractClass(type) && (res.getFullyQualifiedName().equals(value)) )
//								return true;
//							//check to see if value is a subtype in the hierarchy
//							try {
//								ITypeHierarchy hierarchy = res.newTypeHierarchy(jp, null);
//								if (containsType(hierarchy.getAllSubtypes(res), type)) 									
//									return true;
//								
//							} catch (JavaModelException e) {
//								//ignore
//							}
//						}
//					}
//				}
			}
		}
		addNewValidationMessage(Messages.JavaClassType_not_found);
		return false;
	}
	
	private boolean containsType(IType[] types, IType type) {
		for (int i=0;i < types.length;i++) {
			if (type.equals(types[i]))
				return true;
		}
		return false;
	}

	private IType getTypeForValue(IJavaProject jp, String value) {
		try {
			return findType(jp, value);
		} catch (JavaModelException e) {
            // suppress and fall through to return null
		}
		return null;
	}

	/**
	 * @return String value of {@link #POSSIBLE_VALUES_SUPERCLASS_PROP_NAME}
	 */
	protected String getSuperClassName(){
		return getTraitValueAsString(POSSIBLE_VALUES_SUPERCLASS_PROP_NAME);
//		return CMAnnotationHelper.getCMAttributePropertyValue(getMetaDataContext().getBundleId(), getMetaDataContext().getUri(),
//				getMetaDataContext().getElementName(), getMetaDataContext().getAttributeName(),
//				POSSIBLE_VALUES_SUPERCLASS_PROP_NAME);

	}
	
	/**
	 * @return List of values from {@link #POSSIBLE_VALUES_INTERFACES_PROP_NAME}
	 */
	protected List getInterfaceNames(){
		return getTraitValueAsListOfStrings(POSSIBLE_VALUES_INTERFACES_PROP_NAME);
		
//		return CMAnnotationHelper.getCMAttributePropertyValues(getMetaDataContext().getBundleId(), getMetaDataContext().getUri(),
//				getMetaDataContext().getElementName(), getMetaDataContext().getAttributeName(),
//				POSSIBLE_VALUES_INTERFACES_PROP_NAME);

	}

	/**
	 * Create a {@link ValidationMessage} from metadata or use default message
	 * and add it to the collection of validation messages
	 * @param defaultMsg
	 */
	protected void addNewValidationMessage(String defaultMsg) {
		//TODO: need to refactor below as this as also in Enumeration
		String msg = getCMValidationMessage();
		if (msg == null || msg.equals("")) //$NON-NLS-1$
			msg = defaultMsg;
		
		String code = getValidationCode();
		int severity = getValidationSeverity();
		ValidationMessage val = new ValidationMessage(msg, code, severity);
		getValidationMessages().add(val);
	}
	
	
	/**
	 * @return validation message from meta-data using {@link IValidValues}.VALID_VALUES_MESSAGE_PROP_NAME trait.   Can be null.
	 */
	protected String getCMValidationMessage() {
		return getTraitValueAsString(IValidValues.VALID_VALUES_MESSAGE_PROP_NAME);			
	}
	
	/**
	 * @return validation severity as int from meta-data using {@link IValidValues}.VALID_VALUES_SEVERITY_PROP_NAME trait.   IStatus.WARNING is default.
	 */
	protected int getValidationSeverity() {
		String val = getTraitValueAsString(IValidValues.VALID_VALUES_SEVERITY_PROP_NAME);		
		if (val == null)
			return IStatus.WARNING;
		
		int severity = Integer.valueOf(val).intValue();
		return severity;
	}

	/**
	 * @return validation code as String from meta-data.   Can be null.
	 */
	protected String getValidationCode() {
		return getTraitValueAsString(IValidValues.VALID_VALUES_CODE_PROP_NAME);		
	}
	
	private boolean isInnerOrAnonymousClass(IType res) {
		try {
			if (res.isClass() && (res.isAnonymous() || 
									(Flags.isPrivate(res.getFlags())) || 
									res.getFullyQualifiedName().indexOf("$") > 0)) //must be better way to discover if it is an inner class //$NON-NLS-1$
				return true;
		} catch (JavaModelException e) {
			//ignore
		}
		return false;
	}


	private boolean isAbstractClass(IType res) {	
		try {
			if (res.isClass() && Flags.isAbstract(res.getFlags()))
				return true;
		} catch (JavaModelException e) {
			//ignore
		}
		return false;
	}
	
	private static class Searcher extends SearchRequestor{
		private List results = new ArrayList();
		public void acceptSearchMatch(SearchMatch match) throws CoreException {
			results.add(match);
		}
		
		/**
		 * @return list of serach results
		 */
		public List getResults(){
			return results;
		}
	}
	
/////////////////  ///////////////////////////////////////////////////////////////////////
//remainder of this class copied from org.eclipse.jdt.internal.corext.util.JavaCoreUtil //
//TODO: find public version of this functionality										//
//////////////////////////////////////////////////////////////////////////////////////////
	private IType findType(IJavaProject jproject, String fullyQualifiedName) throws JavaModelException {
		//workaround for bug 22883
		IType type= jproject.findType(fullyQualifiedName);
		if (type != null)
			return type;

		IPackageFragmentRoot[] roots= jproject.getPackageFragmentRoots();
		for (int i= 0; i < roots.length; i++) {
			IPackageFragmentRoot root= roots[i];
			type= findType(root, fullyQualifiedName);
			if (type != null && type.exists())
				return type;
		}	
		return null;
	}
	
	private IType findType(IPackageFragmentRoot root, String fullyQualifiedName) throws JavaModelException{
		IJavaElement[] children= root.getChildren();
		for (int i= 0; i < children.length; i++) {
			IJavaElement element= children[i];
			if (element.getElementType() == IJavaElement.PACKAGE_FRAGMENT){
				IPackageFragment pack= (IPackageFragment)element;
				if (! fullyQualifiedName.startsWith(pack.getElementName()))
					continue;
				IType type= findType(pack, fullyQualifiedName);
				if (type != null && type.exists())
					return type;
			}
		}		
		return null;
	}
	
	private IType findType(IPackageFragment pack, String fullyQualifiedName) throws JavaModelException{
		ICompilationUnit[] cus= pack.getCompilationUnits();
		for (int i= 0; i < cus.length; i++) {
			ICompilationUnit unit= cus[i];
			IType type= findType(unit, fullyQualifiedName);
			if (type != null && type.exists())
				return type;
		}
		return null;
	}
	
	private IType findType(ICompilationUnit cu, String fullyQualifiedName) throws JavaModelException{
		IType[] types= cu.getAllTypes();
		for (int i= 0; i < types.length; i++) {
			IType type= types[i];
			if (getFullyQualifiedName(type).equals(fullyQualifiedName))
				return type;
		}
		return null;
	}
	
	private String getFullyQualifiedName(IType type) {
		try {
			if (type.isBinary() && !type.isAnonymous()) {
				IType declaringType= type.getDeclaringType();
				if (declaringType != null) {
					return getFullyQualifiedName(declaringType) + '.' + type.getElementName();
				}
			}
		} catch (JavaModelException e) {
			// ignore
		}		
		return type.getFullyQualifiedName('.');
	}
////////////////////////////////////////////////////////////////////////
}