/*******************************************************************************
* Copyright (c) 2003, 2012 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.j2ee.internal.common.operations;
import static org.eclipse.jst.j2ee.internal.common.operations.INewJavaClassDataModelProperties.ABSTRACT_METHODS;
import static org.eclipse.jst.j2ee.internal.common.operations.INewJavaClassDataModelProperties.CLASS_NAME;
import static org.eclipse.jst.j2ee.internal.common.operations.INewJavaClassDataModelProperties.CONSTRUCTOR;
import static org.eclipse.jst.j2ee.internal.common.operations.INewJavaClassDataModelProperties.GENERATE_DD;
import static org.eclipse.jst.j2ee.internal.common.operations.INewJavaClassDataModelProperties.INTERFACES;
import static org.eclipse.jst.j2ee.internal.common.operations.INewJavaClassDataModelProperties.JAVA_PACKAGE;
import static org.eclipse.jst.j2ee.internal.common.operations.INewJavaClassDataModelProperties.JAVA_PACKAGE_FRAGMENT_ROOT;
import static org.eclipse.jst.j2ee.internal.common.operations.INewJavaClassDataModelProperties.JAVA_SOURCE_FOLDER;
import static org.eclipse.jst.j2ee.internal.common.operations.INewJavaClassDataModelProperties.MAIN_METHOD;
import static org.eclipse.jst.j2ee.internal.common.operations.INewJavaClassDataModelProperties.MODIFIER_ABSTRACT;
import static org.eclipse.jst.j2ee.internal.common.operations.INewJavaClassDataModelProperties.MODIFIER_FINAL;
import static org.eclipse.jst.j2ee.internal.common.operations.INewJavaClassDataModelProperties.MODIFIER_PUBLIC;
import static org.eclipse.jst.j2ee.internal.common.operations.INewJavaClassDataModelProperties.OPEN_IN_EDITOR;
import static org.eclipse.jst.j2ee.internal.common.operations.INewJavaClassDataModelProperties.PROJECT;
import static org.eclipse.jst.j2ee.internal.common.operations.INewJavaClassDataModelProperties.QUALIFIED_CLASS_NAME;
import static org.eclipse.jst.j2ee.internal.common.operations.INewJavaClassDataModelProperties.SOURCE_FOLDER;
import static org.eclipse.jst.j2ee.internal.common.operations.INewJavaClassDataModelProperties.SUPERCLASS;
import java.lang.reflect.Modifier;
import java.net.URI;
import java.util.Set;
import org.eclipse.core.filesystem.EFS;
import org.eclipse.core.filesystem.IFileStore;
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.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.core.ICompilationUnit;
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.JavaConventions;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jem.workbench.utility.JemProjectUtilities;
import org.eclipse.jst.j2ee.internal.common.J2EECommonMessages;
import org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin;
import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
import org.eclipse.osgi.util.NLS;
import org.eclipse.wst.common.componentcore.internal.operation.ArtifactEditOperationDataModelProvider;
import org.eclipse.wst.common.frameworks.datamodel.IDataModelOperation;
import org.eclipse.wst.common.frameworks.internal.plugin.WTPCommonPlugin;
/**
* This data model provider is a subclass of AbstractDataModelProvider and follows the
* IDataModelOperation and Data Model Wizard frameworks.
*
* @see org.eclipse.wst.common.frameworks.datamodel.AbstractDataModelProvider
*
* This data model provider extends the ArtifactEditOperationDataModelProvider to get project name
* and artifact edit information that during the operation, the artifact edit model can be used to
* save changes.
* @see org.eclipse.wst.common.componentcore.internal.operation.ArtifactEditOperationDataModelProvider
*
* The NewJavaClassDataModelProvider is used to store all the base properties which would be needed
* to generate a new instance of a java class. Validations for these properties such as class name,
* package name, superclass, and modifiers are also provided.
*
* The INewJavaClassDataModelProperties is implemented to store all of the property names.
* @see org.eclipse.jst.j2ee.internal.common.operations.INewJavaClassDataModelProperties
*
* Clients must subclass this data model provider and the properties interface to use it and to
* cache and provide their own specific attributes. They should also provide their own validation
* methods and default values for the properties they add.
*
*/
public class NewJavaClassDataModelProvider extends ArtifactEditOperationDataModelProvider {
/**
* Subclasses may extend this method to perform their own validation. This method should not
* return null. It does not accept null as a parameter.
*
* @see NewJavaClassDataModelProvider#validate(String)
*
* @param folderFullPath
* @return IStatus
*/
protected IStatus validateJavaSourceFolder(String folderFullPath) {
// Ensure that the source folder path is not empty
if (folderFullPath == null || folderFullPath.length() == 0) {
String msg = J2EECommonMessages.ERR_JAVA_CLASS_FOLDER_NAME_EMPTY;
return WTPCommonPlugin.createErrorStatus(msg);
}
// Ensure that the source folder path is absolute
else if (!new Path(folderFullPath).isAbsolute()) {
String msg = J2EECommonMessages.ERR_JAVA_CLASS_FOLDER_NOT_ABSOLUTE;
return WTPCommonPlugin.createErrorStatus(msg);
}
IProject project = getTargetProject();
// Ensure project is not closed
if (project == null) {
String msg = J2EECommonMessages.ERR_JAVA_CLASS_FOLDER_NOT_EXIST;
return WTPCommonPlugin.createErrorStatus(msg);
}
// Ensure project is accessible.
if (!project.isAccessible()) {
String msg = J2EECommonMessages.ERR_JAVA_CLASS_FOLDER_NOT_EXIST;
return WTPCommonPlugin.createErrorStatus(msg);
}
// Ensure the project is a java project.
try {
if (!project.hasNature(JavaCore.NATURE_ID)) {
String msg = J2EECommonMessages.ERR_JAVA_CLASS_NOT_JAVA_PROJECT;
return WTPCommonPlugin.createErrorStatus(msg);
}
} catch (CoreException e) {
J2EEPlugin.logError(e);
}
// Ensure the selected folder is a valid java source folder for the component
IFolder sourcefolder = getJavaSourceFolder();
if (sourcefolder == null || (!sourcefolder.getFullPath().equals(new Path(folderFullPath)))) {
String msg = J2EECommonMessages.getResourceString(J2EECommonMessages.ERR_JAVA_CLASS_FOLDER_NOT_SOURCE, new String[]{folderFullPath});
return WTPCommonPlugin.createErrorStatus(msg);
}
// Valid source is selected
return WTPCommonPlugin.OK_STATUS;
}
/**
* Subclasses may extend this method to perform their own retrieval of a default java source
* folder. This implementation returns the first source folder in the project for the component.
* This method may return null.
*
* @return IFolder instance of default java source folder
*/
protected IFolder getDefaultJavaSourceFolder() {
IProject project = getTargetProject();
if (project == null)
return null;
IPackageFragmentRoot[] sources = J2EEProjectUtilities.getSourceContainers(project);
// Try and return the first source folder
if (sources.length > 0) {
try {
return (IFolder) sources[0].getCorrespondingResource();
} catch (Exception e) {
return null;
}
}
return null;
}
/**
* Subclasses may extend this method to create their own specialized default WTP operation. This
* implementation creates an instance of the NewJavaClassOperation to create a new java class.
* This method will not return null.
*
* @see WTPOperationDataModel#getDefaultOperation()
* @see NewJavaClassOperation
*
* @return WTPOperation
*/
@Override
public IDataModelOperation getDefaultOperation() {
return new NewJavaClassOperation(getDataModel());
}
/**
* Subclasses may extend this method to add their own data model's properties as valid base
* properties.
*
* @see org.eclipse.wst.common.frameworks.datamodel.IDataModelProvider#getPropertyNames()
*/
@Override
public Set getPropertyNames() {
Set propertyNames = super.getPropertyNames();
propertyNames.add(SOURCE_FOLDER);
propertyNames.add(JAVA_PACKAGE);
propertyNames.add(CLASS_NAME);
propertyNames.add(SUPERCLASS);
propertyNames.add(MODIFIER_PUBLIC);
propertyNames.add(MODIFIER_ABSTRACT);
propertyNames.add(MODIFIER_FINAL);
propertyNames.add(INTERFACES);
propertyNames.add(MAIN_METHOD);
propertyNames.add(CONSTRUCTOR);
propertyNames.add(ABSTRACT_METHODS);
propertyNames.add(OPEN_IN_EDITOR);
propertyNames.add(JAVA_PACKAGE_FRAGMENT_ROOT);
propertyNames.add(JAVA_SOURCE_FOLDER);
propertyNames.add(PROJECT);
propertyNames.add(QUALIFIED_CLASS_NAME);
propertyNames.add(GENERATE_DD);
return propertyNames;
}
/**
* Subclasses may extend this method to add the default values for their own specific data model
* properties. This declares the default values for the new java class. This method does not
* accept null. It may return null.
*
* @see org.eclipse.wst.common.frameworks.datamodel.IDataModelProvider#getDefaultProperty(String)
*
* @param propertyName
* @return default object value of the property
*/
@Override
public Object getDefaultProperty(String propertyName) {
// Get the default source folder for the project
if (propertyName.equals(SOURCE_FOLDER)) {
IFolder sourceFolder = getDefaultJavaSourceFolder();
if (sourceFolder != null && sourceFolder.exists())
return sourceFolder.getFullPath().toOSString();
}
// Use Object as the default superclass if one is not specified
else if (propertyName.equals(SUPERCLASS))
return new String("java.lang.Object"); //$NON-NLS-1$
// Use public as default visibility
else if (propertyName.equals(MODIFIER_PUBLIC))
return Boolean.TRUE;
// Generate constructors from the superclass by default
else if (propertyName.equals(CONSTRUCTOR))
return Boolean.TRUE;
// Generate unimplemented methods from declared interfaces by default
else if (propertyName.equals(ABSTRACT_METHODS))
return Boolean.TRUE;
// Open the generated java class in the editor by default
else if (propertyName.equals(OPEN_IN_EDITOR))
return Boolean.TRUE;
else if (propertyName.equals(PROJECT))
return getTargetProject();
else if (propertyName.equals(JAVA_SOURCE_FOLDER))
return getJavaSourceFolder();
else if (propertyName.equals(JAVA_PACKAGE_FRAGMENT_ROOT))
return getJavaPackageFragmentRoot();
else if (propertyName.equals(QUALIFIED_CLASS_NAME))
return getQualifiedClassName();
else if (GENERATE_DD.equals(propertyName))
return Boolean.FALSE;
return super.getDefaultProperty(propertyName);
}
/**
* This method will return the qualified java class name as specified by the class name and
* package name properties in the data model. This method should not return null.
*
* @see #CLASS_NAME
* @see #JAVA_PACKAGE
*
* @return String qualified java classname
*/
private String getQualifiedClassName() {
// Use the java package name and unqualified class name to create a qualified java class
// name
String packageName = getStringProperty(JAVA_PACKAGE);
String className = getStringProperty(CLASS_NAME);
// Ensure the class is not in the default package before adding package name to qualified
// name
if (packageName != null && packageName.trim().length() > 0)
return packageName + "." + className; //$NON-NLS-1$
return className;
}
/**
* Subclasses may override this method to provide their own validation of any of the data
* model's properties. This implementation ensures that a java class can be properly generated
* from the values as specified. This method will not return null. This method will not accept
* null as a parameter.
*
* @see org.eclipse.wst.common.frameworks.datamodel.IDataModelProvider#validate(java.lang.String)
*
* @param propertyName
* @return IStatus of the validity of the specifiec property
*/
@Override
public IStatus validate(String propertyName) {
IStatus result = super.validate(propertyName);
if (result != null && !result.isOK())
return result;
if (propertyName.equals(SOURCE_FOLDER))
return validateJavaSourceFolder(getStringProperty(propertyName));
if (propertyName.equals(JAVA_PACKAGE))
return validateJavaPackage(getStringProperty(propertyName));
if (propertyName.equals(CLASS_NAME)) {
result = validateJavaClassName(getStringProperty(propertyName));
if (result.getSeverity() != IStatus.ERROR) {
IStatus existsStatus = canCreateTypeInClasspath(getStringProperty(CLASS_NAME));
if (existsStatus.matches(IStatus.ERROR | IStatus.WARNING))
result = existsStatus;
}
}
if (propertyName.equals(SUPERCLASS))
return validateSuperclass(getStringProperty(propertyName));
if (propertyName.equals(MODIFIER_ABSTRACT) || propertyName.equals(MODIFIER_FINAL))
return validateModifier(propertyName, getBooleanProperty(propertyName));
if (result == null) {
result = WTPCommonPlugin.OK_STATUS;
}
return result;
}
/**
* This method will validate whether the specified package name is a valid java package name. It
* will be called during the doValidateProperty(String). This method will accept null. It will
* not return null.
*
* @see NewJavaClassDataModelProvider#validate(String)
*
* @param packName --
* the package name
* @return IStatus of if the package name is valid
*/
private IStatus validateJavaPackage(String packName) {
if (packName != null && packName.trim().length() > 0) {
// Use standard java conventions to validate the package name
IStatus javaStatus = JavaConventions.validatePackageName(packName);
if (javaStatus.getSeverity() == IStatus.ERROR) {
String msg = J2EECommonMessages.ERR_JAVA_PACAKGE_NAME_INVALID + javaStatus.getMessage();
return WTPCommonPlugin.createErrorStatus(msg);
} else if (javaStatus.getSeverity() == IStatus.WARNING) {
String msg = J2EECommonMessages.ERR_JAVA_PACKAGE_NAME_WARNING + javaStatus.getMessage();
return WTPCommonPlugin.createWarningStatus(msg);
}
}
// java package name is valid
return WTPCommonPlugin.OK_STATUS;
}
/**
* Subclasses may override this method to provide their own validation of the class name. This
* implementation will verify if the specified class name is a valid UNQUALIFIED java class
* name. This method will not accept null. It will not return null.
*
* @see NewJavaClassDataModelProvider#validate(String)
*
* @param className
* @return IStatus of if java class name is valid
*/
protected IStatus validateJavaClassName(String className) {
// Ensure the class name is not empty
if (className == null || className.trim().length() == 0) {
String msg = J2EECommonMessages.ERR_JAVA_CLASS_NAME_EMPTY;
return WTPCommonPlugin.createErrorStatus(msg);
}
// Do not allow qualified name
if (className.lastIndexOf('.') != -1) {
String msg = J2EECommonMessages.ERR_JAVA_CLASS_NAME_QUALIFIED;
return WTPCommonPlugin.createErrorStatus(msg);
}
// Check Java class name by standard java conventions
IStatus javaStatus = JavaConventions.validateJavaTypeName(className);
if (javaStatus.getSeverity() == IStatus.ERROR) {
String msg = J2EECommonMessages.ERR_JAVA_CLASS_NAME_INVALID + javaStatus.getMessage();
return WTPCommonPlugin.createErrorStatus(msg);
} else if (javaStatus.getSeverity() == IStatus.WARNING) {
String msg = J2EECommonMessages.ERR_JAVA_CLASS_NAME_WARNING + javaStatus.getMessage();
return WTPCommonPlugin.createWarningStatus(msg);
}
return WTPCommonPlugin.OK_STATUS;
}
/**
* This method will verify the specified superclass can be subclassed. It ensures the superclass
* is a valid java class, that it exists, and that it is not final. This method will accept
* null. It will not return null.
*
* @see NewJavaClassDataModelProvider#validate(String)
*
* @param superclassName
* @return IStatus of if the superclass can be subclassed
*/
private IStatus validateSuperclass(String superclassName) {
// Ensure the superclass name is not empty
if (superclassName == null || superclassName.trim().length() == 0) {
String msg = J2EECommonMessages.ERR_JAVA_CLASS_NAME_EMPTY;
return WTPCommonPlugin.createErrorStatus(msg);
}
// In default case of Object, return OK right away
if (superclassName.equals("java.lang.Object")) //$NON-NLS-1$
return WTPCommonPlugin.OK_STATUS;
// Ensure the unqualified java class name of the superclass is valid
String className = superclassName;
int index = superclassName.lastIndexOf("."); //$NON-NLS-1$
if (index != -1) {
className = superclassName.substring(index + 1);
}
IStatus status = validateJavaClassName(className);
// If unqualified super class name is valid, ensure validity of superclass itself
if (status.getSeverity() != IStatus.ERROR) {
// If the superclass does not exist, throw an error
IJavaProject javaProject = JemProjectUtilities.getJavaProject(getTargetProject());
IType supertype = null;
try {
supertype = javaProject.findType(superclassName);
} catch (Exception e) {
// Just throw error below
}
if (supertype == null) {
String msg = J2EECommonMessages.ERR_JAVA_CLASS_SUPERCLASS_NOT_EXIST;
return WTPCommonPlugin.createErrorStatus(msg);
}
// Ensure the superclass is not final
int flags = -1;
try {
flags = supertype.getFlags();
if (Modifier.isFinal(flags)) {
String msg = J2EECommonMessages.ERR_JAVA_CLASS_SUPERCLASS_FINAL;
return WTPCommonPlugin.createErrorStatus(msg);
}
} catch (Exception e) {
J2EEPlugin.logError(e);
}
}
// Return status of specified superclass
return status;
}
/**
* This method will ensure that if the abstract modifier is set, that final is not set, and
* vice-versa, as this is not supported either way. This method will not accept null. It will
* not return null.
*
* @see NewJavaClassDataModelProvider#validate(String)
*
* @param prop
* @return IStatus of whether abstract value is valid
*/
private IStatus validateModifier(String propertyName, boolean prop) {
// Throw an error if both Abstract and Final are checked
if (prop) {
// Ensure final is not also checked
if (propertyName.equals(MODIFIER_ABSTRACT) && getBooleanProperty(MODIFIER_FINAL)) {
String msg = J2EECommonMessages.ERR_BOTH_FINAL_AND_ABSTRACT;
return WTPCommonPlugin.createErrorStatus(msg);
}
// Ensure abstract is not also checked
if (propertyName.equals(MODIFIER_FINAL) && getBooleanProperty(MODIFIER_ABSTRACT)) {
String msg = J2EECommonMessages.ERR_BOTH_FINAL_AND_ABSTRACT;
return WTPCommonPlugin.createErrorStatus(msg);
}
}
// Abstract and final settings are valid
return WTPCommonPlugin.OK_STATUS;
}
/**
* This method is intended for internal use only. This will check the java model for the
* specified javaproject in the data model for the existence of the passed in qualified
* classname. This method does not accept null. It may return null.
*
* @see NewJavaClassDataModelProvider#getTargetProject()
* @see JavaModelUtil#findType(IJavaProject, String)
*
* @param fullClassName
* @return IType for the specified classname
*/
protected IStatus canCreateTypeInClasspath(String className) {
String packageName = getStringProperty(JAVA_PACKAGE);
return canCreateTypeInClasspath(packageName, className);
}
protected IStatus canCreateTypeInClasspath(String packageName, String typeName) {
IPackageFragmentRoot packRoot = getJavaPackageFragmentRoot();
IPackageFragment pack = null;
// bug 308013 - getJavaPackageFragmentRoot() can return null- need to check for that
if (packRoot != null)
{
pack = packRoot.getPackageFragment(packageName);
}
if (pack != null) {
ICompilationUnit cu = pack.getCompilationUnit(typeName + JavaModelUtil.DEFAULT_CU_SUFFIX);
String fullyQualifiedName = JavaModelUtil.getFullyQualifiedName(cu.getType(typeName));
IResource resource = cu.getResource();
if (resource.exists()) {
String message = NLS.bind(
J2EECommonMessages.ERR_TYPE_ALREADY_EXIST,
new Object[] { fullyQualifiedName });
return WTPCommonPlugin.createErrorStatus(message);
}
URI location = resource.getLocationURI();
if (location != null) {
try {
IFileStore store= EFS.getStore(location);
if (store.fetchInfo().exists()) {
String message = NLS.bind(
J2EECommonMessages.ERR_TYPE_DIFFERENT_CASE_EXIST,
new Object[] { fullyQualifiedName });
return WTPCommonPlugin.createErrorStatus(message);
}
} catch (CoreException e) {
J2EEPlugin.logError(e);
}
}
}
return WTPCommonPlugin.OK_STATUS;
}
/**
* This will return the IFolder instance for the specified folder name in the data model. This
* method may return null.
*
* @see #SOURCE_FOLDER
* @see NewJavaClassDataModelProvider#getAllSourceFolders()
*
* @return IFolder java source folder
*/
protected final IFolder getJavaSourceFolder() {
IPackageFragmentRoot[] sources = J2EEProjectUtilities.getSourceContainers(getTargetProject());
// Ensure there is valid source folder(s)
if (sources == null || sources.length == 0)
return null;
String folderFullPath = getStringProperty(SOURCE_FOLDER);
// Get the source folder whose path matches the source folder name value in the data model
for (int i = 0; i < sources.length; i++) {
if (sources[i].getPath().equals(new Path(folderFullPath))) {
try {
return (IFolder) sources[i].getCorrespondingResource();
} catch (Exception e) {
break;
}
}
}
return null;
}
/**
* Subclasses may extend this method to perform their own retrieval mechanism. This
* implementation simply returns the JDT package fragment root for the selected source folder.
* This method may return null.
*
* @see IJavaProject#getPackageFragmentRoot(org.eclipse.core.resources.IResource)
*
* @return IPackageFragmentRoot
*/
protected IPackageFragmentRoot getJavaPackageFragmentRoot() {
IProject project = getTargetProject();
if (project != null) {
IJavaProject aJavaProject = JemProjectUtilities.getJavaProject(project);
// Return the source folder for the java project of the selected project
if (aJavaProject != null) {
IFolder sourcefolder = (IFolder) getProperty(JAVA_SOURCE_FOLDER);
if (sourcefolder != null)
return aJavaProject.getPackageFragmentRoot(sourcefolder);
}
}
return null;
}
/**
* This method ensures the source folder is updated if the component is changed.
*
* @see org.eclipse.wst.common.frameworks.datamodel.IDataModelProvider#propertySet(String,
* Object)
*
* @return boolean if property set successfully
*/
@Override
public boolean propertySet(String propertyName, Object propertyValue) {
boolean result = super.propertySet(propertyName, propertyValue);
if (result) {
if (COMPONENT_NAME.equals(propertyName) || PROJECT_NAME.equals(propertyName)){
if( getDefaultJavaSourceFolder() != null ){
setProperty(SOURCE_FOLDER, getDefaultJavaSourceFolder().getFullPath().toOSString());
}
}
}
return result;
}
}