/*
* The Apache Software License, Version 1.1
*
* Copyright (c) 2001-2002 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution, if
* any, must include the following acknowlegement:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowlegement may appear in the software itself,
* if and wherever such third-party acknowlegements normally appear.
*
* 4. The names "The Jakarta Project", "Ant", and "Apache Software
* Foundation" must not be used to endorse or promote products derived
* from this software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache"
* nor may "Apache" appear in their names without prior written
* permission of the Apache Group.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*/
package org.apache.tools.ant.taskdefs.optional.ide;
import java.util.Vector;
import java.util.Enumeration;
import java.io.File;
import com.ibm.ivj.util.base.Package;
import com.ibm.ivj.util.base.IvjException;
import com.ibm.ivj.util.base.Workspace;
import com.ibm.ivj.util.base.ToolEnv;
import com.ibm.ivj.util.base.ExportCodeSpec;
import com.ibm.ivj.util.base.ProjectEdition;
import com.ibm.ivj.util.base.ImportCodeSpec;
import com.ibm.ivj.util.base.Type;
import com.ibm.ivj.util.base.Project;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.DirectoryScanner;
/**
* Helper class for VAJ tasks. Holds Workspace singleton and
* wraps IvjExceptions into BuildExceptions
*
* @author Wolf Siberski, TUI Infotec GmbH
*/
abstract class VAJLocalUtil implements VAJUtil{
// singleton containing the VAJ workspace
private static Workspace workspace;
/**
* Wraps IvjException into a BuildException
*
* @return org.apache.tools.ant.BuildException
* @param errMsg Additional error message
* @param e IvjException which is wrapped
*/
static BuildException createBuildException(
String errMsg, IvjException e) {
errMsg = errMsg + "\n" + e.getMessage();
String[] errors = e.getErrors();
if (errors != null) {
for (int i = 0; i < errors.length; i++) {
errMsg = errMsg + "\n" + errors[i];
}
}
return new BuildException(errMsg, e);
}
/**
* returns the current VAJ workspace.
* @return com.ibm.ivj.util.base.Workspace
*/
static Workspace getWorkspace() {
if (workspace == null) {
workspace = ToolEnv.connectToWorkspace();
if (workspace == null) {
throw new BuildException(
"Unable to connect to Workspace! "
+ "Make sure you are running in VisualAge for Java.");
}
}
return workspace;
}
//-----------------------------------------------------------
// export
//-----------------------------------------------------------
/**
* export packages
*/
public void exportPackages(
File dest,
String[] includePatterns, String[] excludePatterns,
boolean exportClasses, boolean exportDebugInfo,
boolean exportResources, boolean exportSources,
boolean useDefaultExcludes, boolean overwrite) {
if (includePatterns == null || includePatterns.length == 0) {
log("You must specify at least one include attribute. "
+ "Not exporting", MSG_ERR);
} else {
try {
VAJWorkspaceScanner scanner = new VAJWorkspaceScanner();
scanner.setIncludes(includePatterns);
scanner.setExcludes(excludePatterns);
if (useDefaultExcludes) {
scanner.addDefaultExcludes();
}
scanner.scan();
Package[] packages = scanner.getIncludedPackages();
log("Exporting " + packages.length + " package(s) to "
+ dest, MSG_INFO);
for (int i = 0; i < packages.length; i++) {
log(" " + packages[i].getName(), MSG_VERBOSE);
}
ExportCodeSpec exportSpec = new ExportCodeSpec();
exportSpec.setPackages(packages);
exportSpec.includeJava(exportSources);
exportSpec.includeClass(exportClasses);
exportSpec.includeResources(exportResources);
exportSpec.includeClassDebugInfo(exportDebugInfo);
exportSpec.useSubdirectories(true);
exportSpec.overwriteFiles(overwrite);
exportSpec.setExportDirectory(dest.getAbsolutePath());
getWorkspace().exportData(exportSpec);
} catch (IvjException ex) {
throw createBuildException("Exporting failed!", ex);
}
}
}
//-----------------------------------------------------------
// load
//-----------------------------------------------------------
/**
* Load specified projects.
*/
public void loadProjects(Vector projectDescriptions) {
Vector expandedDescs = getExpandedDescriptions(projectDescriptions);
// output warnings for projects not found
for (Enumeration e = projectDescriptions.elements(); e.hasMoreElements();) {
VAJProjectDescription d = (VAJProjectDescription) e.nextElement();
if (!d.projectFound()) {
log("No Projects match the name " + d.getName(), MSG_WARN);
}
}
log("Loading " + expandedDescs.size()
+ " project(s) into workspace", MSG_INFO);
for (Enumeration e = expandedDescs.elements();
e.hasMoreElements();) {
VAJProjectDescription d = (VAJProjectDescription) e.nextElement();
ProjectEdition pe = findProjectEdition(d.getName(), d.getVersion());
try {
log("Loading '" + d.getName() + "', Version '" + d.getVersion()
+ "', into Workspace", MSG_VERBOSE);
pe.loadIntoWorkspace();
} catch (IvjException ex) {
throw createBuildException("Project '" + d.getName()
+ "' could not be loaded.", ex);
}
}
}
/**
* returns a list of project names matching the given pattern
*/
private Vector findMatchingProjects(String pattern) {
String[] projectNames;
try {
projectNames = getWorkspace().getRepository().getProjectNames();
} catch (IvjException e) {
throw createBuildException("VA Exception occured: ", e);
}
Vector matchingProjects = new Vector();
for (int i = 0; i < projectNames.length; i++) {
if (VAJWorkspaceScanner.match(pattern, projectNames[i])) {
matchingProjects.addElement(projectNames[i]);
}
}
return matchingProjects;
}
/**
* return project descriptions containing full project names instead
* of patterns with wildcards.
*/
private Vector getExpandedDescriptions(Vector projectDescs) {
Vector expandedDescs = new Vector(projectDescs.size());
try {
String[] projectNames =
getWorkspace().getRepository().getProjectNames();
for (int i = 0; i < projectNames.length; i++) {
for (Enumeration e = projectDescs.elements();
e.hasMoreElements();) {
VAJProjectDescription d = (VAJProjectDescription) e.nextElement();
String pattern = d.getName();
if (VAJWorkspaceScanner.match(pattern, projectNames[i])) {
d.setProjectFound();
expandedDescs.addElement(new VAJProjectDescription(
projectNames[i], d.getVersion()));
break;
}
}
}
} catch (IvjException e) {
throw createBuildException("VA Exception occured: ", e);
}
return expandedDescs;
}
/**
* Finds a specific project edition in the repository.
*
* @param name project name
* @param versionName project version name
* @return com.ibm.ivj.util.base.ProjectEdition the specified edition
*/
private ProjectEdition findProjectEdition(
String name, String versionName) {
try {
ProjectEdition[] editions = null;
editions = getWorkspace().getRepository().getProjectEditions(name);
if (editions == null) {
throw new BuildException("Project " + name + " doesn't exist");
}
ProjectEdition pe = null;
for (int i = 0; i < editions.length && pe == null; i++) {
if (versionName.equals(editions[i].getVersionName())) {
pe = editions[i];
}
}
if (pe == null) {
throw new BuildException("Version " + versionName
+ " of Project " + name + " doesn't exist");
}
return pe;
} catch (IvjException e) {
throw createBuildException("VA Exception occured: ", e);
}
}
//-----------------------------------------------------------
// import
//-----------------------------------------------------------
/**
* Do the import.
*/
public void importFiles(
String importProject, File srcDir,
String[] includePatterns, String[] excludePatterns,
boolean importClasses, boolean importResources,
boolean importSources, boolean useDefaultExcludes)
throws BuildException {
if (importProject == null || "".equals(importProject)) {
throw new BuildException("The VisualAge for Java project "
+ "name is required!");
}
ImportCodeSpec importSpec = new ImportCodeSpec();
importSpec.setDefaultProject(getVAJProject(importProject));
DirectoryScanner ds = new DirectoryScanner();
ds.setBasedir(srcDir);
ds.setIncludes(includePatterns);
ds.setExcludes(excludePatterns);
if (useDefaultExcludes) {
ds.addDefaultExcludes();
}
ds.scan();
Vector classes = new Vector();
Vector sources = new Vector();
Vector resources = new Vector();
scanForImport(srcDir, ds.getIncludedFiles(), classes, sources, resources);
StringBuffer summaryLog = new StringBuffer("Importing ");
addFilesToImport(importSpec, importClasses, classes, "Class", summaryLog);
addFilesToImport(importSpec, importSources, sources, "Java", summaryLog);
addFilesToImport(importSpec, importResources, resources, "Resource", summaryLog);
importSpec.setResourcePath(srcDir.getAbsolutePath());
summaryLog.append(" into the project '");
summaryLog.append(importProject);
summaryLog.append("'.");
log(summaryLog.toString(), MSG_INFO);
try {
Type[] importedTypes = getWorkspace().importData(importSpec);
if (importedTypes == null) {
throw new BuildException("Unable to import into Workspace!");
} else {
log(importedTypes.length + " types imported", MSG_DEBUG);
for (int i = 0; i < importedTypes.length; i++) {
log(importedTypes[i].getPackage().getName()
+ "." + importedTypes[i].getName()
+ " into " + importedTypes[i].getProject().getName(),
MSG_DEBUG);
}
}
} catch (IvjException ivje) {
throw createBuildException("Error while importing into workspace: ",
ivje);
}
}
/**
* get a project from the Workspace.
*/
static Project getVAJProject(String importProject) {
Project found = null;
Project[] currentProjects = getWorkspace().getProjects();
for (int i = 0; i < currentProjects.length; i++) {
Project p = currentProjects[i];
if (p.getName().equals(importProject)) {
found = p;
break;
}
}
if (found == null) {
try {
found = getWorkspace().createProject(importProject, true);
} catch (IvjException e) {
throw createBuildException("Error while creating Project "
+ importProject + ": ", e);
}
}
return found;
}
/**
* Sort the files into classes, sources, and resources.
*/
private void scanForImport(
File dir,
String[] files,
Vector classes,
Vector sources,
Vector resources) {
for (int i = 0; i < files.length; i++) {
String file = (new File(dir, files[i])).getAbsolutePath();
if (file.endsWith(".java") || file.endsWith(".JAVA")) {
sources.addElement(file);
} else
if (file.endsWith(".class") || file.endsWith(".CLASS")) {
classes.addElement(file);
} else {
// for resources VA expects the path relative to the resource path
resources.addElement(files[i]);
}
}
}
/**
* Adds files to an import specification. Helper method
* for importFiles()
*
* @param spec import specification
* @param doImport only add files if doImport is true
* @param files the files to add
* @param fileType type of files (Source/Class/Resource)
* @param summaryLog buffer for logging
*/
private void addFilesToImport(ImportCodeSpec spec, boolean doImport,
Vector files, String fileType,
StringBuffer summaryLog) {
if (doImport) {
String[] fileArr = new String[files.size()];
files.copyInto(fileArr);
try {
// here it is assumed that fileType is one of the
// following strings: // "Java", "Class", "Resource"
String methodName = "set" + fileType + "Files";
Class[] methodParams = new Class[]{fileArr.getClass()};
java.lang.reflect.Method method =
spec.getClass().getDeclaredMethod(methodName, methodParams);
method.invoke(spec, new Object[]{fileArr});
} catch (Exception e) {
throw new BuildException(e);
}
if (files.size() > 0) {
logFiles(files, fileType);
summaryLog.append(files.size());
summaryLog.append(" " + fileType.toLowerCase() + " file");
summaryLog.append(files.size() > 1 ? "s, " : ", ");
}
}
}
/**
* Logs a list of file names to the message log
* @param fileNames java.util.Vector file names to be logged
* @param type java.lang.String file type
*/
private void logFiles(Vector fileNames, String fileType) {
log(fileType + " files found for import:", MSG_VERBOSE);
for (Enumeration e = fileNames.elements(); e.hasMoreElements();) {
log(" " + e.nextElement(), MSG_VERBOSE);
}
}
}