incubator-easyant-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From hi...@apache.org
Subject svn commit: r1071697 [17/42] - in /incubator/easyant: buildtypes/ buildtypes/trunk/ buildtypes/trunk/build-osgi-bundle-java/ buildtypes/trunk/build-osgi-bundle-java/src/ buildtypes/trunk/build-osgi-bundle-java/src/main/ buildtypes/trunk/build-osgi-bund...
Date Thu, 17 Feb 2011 17:01:56 GMT
Added: incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/EasyAntEngine.java
URL: http://svn.apache.org/viewvc/incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/EasyAntEngine.java?rev=1071697&view=auto
==============================================================================
--- incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/EasyAntEngine.java (added)
+++ incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/EasyAntEngine.java Thu Feb 17 17:01:07 2011
@@ -0,0 +1,745 @@
+/*
+ *  Copyright 2008-2010 the EasyAnt project
+ *
+ *  See the NOTICE file distributed with this work for additional information
+ *  regarding copyright ownership.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package org.apache.easyant.core;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintStream;
+import java.net.MalformedURLException;
+import java.util.Enumeration;
+import java.util.Properties;
+
+import org.apache.easyant.core.ant.Phase;
+import org.apache.easyant.core.ant.listerners.DefaultEasyAntLogger;
+import org.apache.easyant.core.descriptor.PluginDescriptor;
+import org.apache.easyant.core.factory.EasyantConfigurationFactory;
+import org.apache.easyant.core.ivy.IvyInstanceHelper;
+import org.apache.easyant.core.services.PluginService;
+import org.apache.easyant.core.services.impl.DefaultPluginServiceImpl;
+import org.apache.easyant.tasks.Import;
+import org.apache.easyant.tasks.LoadModule;
+import org.apache.ivy.Ivy;
+import org.apache.ivy.ant.IvyAntSettings;
+import org.apache.ivy.ant.IvyConfigure;
+import org.apache.tools.ant.BuildException;
+import org.apache.tools.ant.BuildListener;
+import org.apache.tools.ant.BuildLogger;
+import org.apache.tools.ant.DemuxInputStream;
+import org.apache.tools.ant.DemuxOutputStream;
+import org.apache.tools.ant.Location;
+import org.apache.tools.ant.MagicNames;
+import org.apache.tools.ant.Main;
+import org.apache.tools.ant.Project;
+import org.apache.tools.ant.ProjectHelper;
+import org.apache.tools.ant.PropertyHelper;
+import org.apache.tools.ant.Target;
+import org.apache.tools.ant.input.DefaultInputHandler;
+import org.apache.tools.ant.input.InputHandler;
+import org.apache.tools.ant.util.ClasspathUtils;
+import org.apache.tools.ant.util.FileUtils;
+import org.apache.tools.ant.util.ProxySetup;
+
+/**
+ * This class provides everything you need to run easyant. This class should be
+ * used to bootstrap easyant from IDE for example
+ */
+public class EasyAntEngine {
+
+	private static final long MEGABYTE = 1024 * 1024;;
+
+	private final EasyAntConfiguration configuration;
+
+	private PluginService pluginService = null;
+
+	/**
+	 * Default constructor will initialize the default configuration
+	 */
+	public EasyAntEngine() {
+		this(EasyantConfigurationFactory.getInstance()
+				.createDefaultConfiguration());
+	}
+
+	/**
+	 * Constructor if you want to use a custom configuration
+	 * 
+	 * @param configuration
+	 */
+	public EasyAntEngine(final EasyAntConfiguration configuration) {
+		this.configuration = configuration;
+	}
+
+	/**
+	 * Configure easyant ivy instance
+	 * 
+	 * @param project
+	 *            project instance
+	 * @return a configured {@link Ivy} instance
+	 */
+	protected Ivy configureEasyAntIvyInstance(Project project) {
+		IvyConfigure easyantIvyConfigure = new IvyConfigure();
+		easyantIvyConfigure
+				.setSettingsId(EasyAntMagicNames.EASYANT_IVY_INSTANCE);
+
+		project
+				.setNewProperty(
+						EasyAntMagicNames.EASYANT_DEFAULT_IVYSETTINGS,
+						this
+								.getClass()
+								.getResource(
+										"/org/apache/easyant/core/default-easyant-ivysettings.xml")
+								.toExternalForm());
+		project
+				.setNewProperty(
+						EasyAntMagicNames.EASYANT_EXTRA_IVYSETTINGS,
+						this
+								.getClass()
+								.getResource(
+										"/org/apache/easyant/core/extra-easyant-ivysettings.xml")
+								.toExternalForm());
+
+		project.setNewProperty(EasyAntMagicNames.EASYANT_CORE_REPO_URL, this
+				.getClass().getResource(
+						"/org/apache/easyant/core/repository/modules")
+				.toExternalForm());
+		if (this.getClass().getResource(
+				"/org/apache/easyant/repository/extra-modules") != null) {
+			project.setNewProperty(EasyAntMagicNames.EASYANT_EXTRA_REPO_URL,
+					this.getClass().getResource(
+							"/org/apache/easyant/repository/extra-modules")
+							.toExternalForm());
+		}
+
+		File userSettings = getUserEasyAntIvySettings(project);
+		String globalSettings = getGlobalEasyAntIvySettings(project);
+		boolean isIgnoringUserIvysettings=Project.toBoolean(project.getProperty(EasyAntMagicNames.IGNORE_USER_IVYSETTINGS));
+
+		if (userSettings.exists() && !isIgnoringUserIvysettings) {
+			project.log("loading user's easyant ivysettings file from "
+					+ userSettings.getAbsolutePath(),Project.MSG_DEBUG);
+			easyantIvyConfigure.setFile(userSettings);
+		} else if (globalSettings != null) {
+			project.log("loading global easyant ivysettings file from "
+					+ globalSettings,Project.MSG_DEBUG);
+			try {
+				easyantIvyConfigure.setUrl(globalSettings);
+			} catch (MalformedURLException malformedUrl) {
+				throw new BuildException(
+						"Unable to parse easyant ivysettings from the following url : "
+								+ globalSettings, malformedUrl);
+			}
+
+		} else {
+			project.log("using easyant default ivy settings file",
+					Project.MSG_VERBOSE);
+			String url = project
+					.getProperty(EasyAntMagicNames.EASYANT_DEFAULT_IVYSETTINGS);
+			try {
+				easyantIvyConfigure.setUrl(url);
+			} catch (MalformedURLException malformedUrl) {
+				throw new BuildException(
+						"Unable to parse easyant ivysettings from the following url : "
+								+ url, malformedUrl);
+			}
+		}
+		easyantIvyConfigure.setProject(project);
+		easyantIvyConfigure.setTaskName("configure-easyant");
+		easyantIvyConfigure.execute();
+
+		IvyAntSettings ivyAntSettings = IvyInstanceHelper
+				.getEasyAntIvyAntSettings(project);
+		return ivyAntSettings.getConfiguredIvyInstance(easyantIvyConfigure);
+	}
+
+	/**
+	 * Get user easyant-ivysettings file
+	 * 
+	 * @param project
+	 * @return the configured user easyant-ivysettings.file
+	 */
+	private File getUserEasyAntIvySettings(Project project) {
+		// path can be specified through a property
+		String path = project
+				.getProperty(EasyAntMagicNames.USER_EASYANT_IVYSETTINGS);
+		// if no property is set check the default location
+		if (path == null) {
+			path = PropertyHelper.getPropertyHelper(project).replaceProperties(
+					EasyAntConstants.DEFAULT_USER_EASYANT_IVYSETTINGS);
+		}
+		project.log("user's easyant-ivysettings file : " + path,
+				Project.MSG_DEBUG);
+		return new File(path);
+	}
+
+	/**
+	 * Get global easyant-ivysettings file
+	 * 
+	 * @param project
+	 * @return the configured global easyant-ivysettings.file
+	 */
+	private String getGlobalEasyAntIvySettings(Project project) {
+		PropertyHelper helper = PropertyHelper.getPropertyHelper(project);
+		String path=null;
+		if (configuration.getEasyantIvySettingsFile() != null) {
+			File f = new File(helper.replaceProperties(configuration.getEasyantIvySettingsFile()));
+			try {
+				path = f.toURL().toExternalForm();
+			} catch (MalformedURLException e) {
+				throw new BuildException("Can't load easyant ivysettings file from "+ f.getAbsolutePath());
+			}
+		}
+		if (configuration.getEasyantIvySettingsUrl() != null) {
+			path = helper.replaceProperties(configuration.getEasyantIvySettingsUrl());
+		}
+		// path can be specified through a property
+		if (path==null && project.getProperty(EasyAntMagicNames.GLOBAL_EASYANT_IVYSETTINGS) != null) {
+			path = project
+					.getProperty(EasyAntMagicNames.GLOBAL_EASYANT_IVYSETTINGS);
+		}
+		// if no property is set check the default location
+		if (path == null) {
+			path = helper.replaceProperties(
+					EasyAntConstants.DEFAULT_GLOBAL_EASYANT_IVYSETTINGS);
+		}
+		project.log("global easyant-ivysettings file : " + path,
+				Project.MSG_DEBUG);
+		return path;
+	}
+
+	protected void configurePluginService(Project project,
+			Ivy easyantIvyInstance) {
+		pluginService = new DefaultPluginServiceImpl(easyantIvyInstance);
+		project.addReference(EasyAntMagicNames.PLUGIN_SERVICE_INSTANCE,
+				pluginService);
+
+	}
+
+	/**
+	 * Adds the listeners specified in the command line arguments, along with
+	 * the default listener, to the specified project.
+	 * 
+	 * @param project
+	 *            The project to add listeners to. Must not be <code>null</code>
+	 *            .
+	 */
+	protected void addBuildListeners(Project project) {
+
+		// Add the default listener
+		project.addBuildListener(createLogger());
+
+		for (int i = 0; i < configuration.getListeners().size(); i++) {
+			String className = (String) configuration.getListeners().elementAt(
+					i);
+			BuildListener listener = (BuildListener) ClasspathUtils
+					.newInstance(className, EasyAntEngine.class
+							.getClassLoader(), BuildListener.class);
+			project.setProjectReference(listener);
+
+			project.addBuildListener(listener);
+		}
+	}
+
+	/**
+	 * Creates the InputHandler and adds it to the project.
+	 * 
+	 * @param project
+	 *            the project instance.
+	 * 
+	 * @exception BuildException
+	 *                if a specified InputHandler implementation could not be
+	 *                loaded.
+	 */
+	protected void addInputHandler(Project project) {
+		InputHandler handler = null;
+
+		if (configuration.getInputHandlerClassname() == null) {
+			handler = new DefaultInputHandler();
+		} else {
+			handler = (InputHandler) ClasspathUtils.newInstance(configuration
+					.getInputHandlerClassname(), Main.class.getClassLoader(),
+					InputHandler.class);
+			project.setProjectReference(handler);
+		}
+		project.setInputHandler(handler);
+	}
+
+	/**
+	 * Creates the default build logger for sending build events to the ant log.
+	 * 
+	 * @return the logger instance for this build.
+	 */
+	protected BuildLogger createLogger() {
+		BuildLogger logger = null;
+		if (configuration.getLoggerClassname() != null) {
+			try {
+				logger = (BuildLogger) ClasspathUtils.newInstance(configuration
+						.getLoggerClassname(), EasyAntEngine.class
+						.getClassLoader(), BuildLogger.class);
+			} catch (BuildException e) {
+				throw new RuntimeException("The specified logger class "
+						+ configuration.getLoggerClassname()
+						+ " could not be used because " + e.getMessage(), e);
+			}
+		} else {
+			logger = new DefaultEasyAntLogger();
+		}
+
+		logger.setMessageOutputLevel(configuration.getMsgOutputLevel());
+		logger.setOutputPrintStream(configuration.getOut());
+		logger.setErrorPrintStream(configuration.getErr());
+		logger.setEmacsMode(configuration.isEmacsMode());
+
+		return logger;
+	}
+
+	/**
+	 * Search parent directories for the build file.
+	 * <p>
+	 * Takes the given target as a suffix to append to each parent directory in
+	 * search of a build file. Once the root of the file-system has been reached
+	 * an exception is thrown.
+	 * 
+	 * @param start
+	 *            Leaf directory of search. Must not be <code>null</code>.
+	 * @param suffix
+	 *            Suffix filename to look for in parents. Must not be
+	 *            <code>null</code>.
+	 * 
+	 * @return A handle to the build file if one is found
+	 * 
+	 * @exception BuildException
+	 *                if no build file is found
+	 */
+	protected File findBuildModule(String start, String suffix)
+			throws BuildException {
+		if (configuration.getMsgOutputLevel() >= Project.MSG_INFO) {
+			System.out.println("Searching for " + suffix + " ...");
+		}
+
+		File parent = new File(new File(start).getAbsolutePath());
+		File file = new File(parent, suffix);
+
+		// check if the target file exists in the current directory
+		while (!file.exists()) {
+			// change to parent directory
+			parent = parent.getParentFile();
+
+			// if parent is null, then we are at the root of the fs,
+			// complain that we can't find the build file.
+			if (parent == null) {
+				throw new BuildException("Could not locate a build file!");
+			}
+
+			// refresh our file handle
+			file = new File(parent, suffix);
+		}
+
+		return file;
+	}
+
+	/**
+	 * configure a given project with current configuration
+	 * 
+	 * @param project
+	 *            a given project
+	 * @throws BuildException
+	 */
+	public void configureProject(Project project) throws BuildException {
+
+		addBuildListeners(project);
+		addInputHandler(project);
+
+		// set the thread priorities
+		if (configuration.getThreadPriority() != null) {
+			try {
+				project.log("Setting Ant's thread priority to "
+						+ configuration.getThreadPriority(),
+						Project.MSG_VERBOSE);
+				Thread.currentThread().setPriority(
+						configuration.getThreadPriority().intValue());
+			} catch (SecurityException swallowed) {
+				// we cannot set the priority here.
+				project
+						.log("A security manager refused to set the -nice value");
+			}
+		}
+
+		project.setKeepGoingMode(configuration.isKeepGoingMode());
+		if (configuration.isProxy()) {
+			// proxy setup if enabledcoreLoader
+			ProxySetup proxySetup = new ProxySetup(project);
+			proxySetup.enableProxies();
+		}
+
+		project.setName("EasyAnt");
+
+	}
+
+	/**
+	 * Initialize an easyant Project
+	 * 
+	 * @param project
+	 */
+	public void initProject(Project project) {
+		project.init();
+		// set user-define properties
+		Enumeration e = configuration.getDefinedProps().keys();
+		while (e.hasMoreElements()) {
+			String arg = (String) e.nextElement();
+			String value = (String) configuration.getDefinedProps().get(arg);
+			project.setUserProperty(arg, value);
+        }
+
+        project.setUserProperty(EasyAntMagicNames.EASYANT_OFFLINE, Boolean.toString(configuration.isOffline()));
+
+		File buildModule = configuration.getBuildModule();
+		File buildFile = configuration.getBuildFile();
+
+		if (buildModule == null) {
+			buildModule = new File(EasyAntConstants.DEFAULT_BUILD_MODULE);
+		}
+
+		if (!buildModule.exists() && configuration.isBuildModuleLookupEnabled()) {
+			buildModule = findBuildModule(System.getProperty("user.dir"),
+					buildModule.toString());
+		}
+
+		// calculate buildFile location based on buildModule directory
+		if (buildModule.exists() && buildFile == null) {
+			buildFile = new File(buildModule.getParentFile(),
+					EasyAntConstants.DEFAULT_BUILD_FILE);
+		}
+
+		if (buildFile == null && configuration.isBuildModuleLookupEnabled()) {
+			buildFile = findBuildModule(System.getProperty("user.dir"),
+					EasyAntConstants.DEFAULT_BUILD_FILE);
+		}
+
+		// Normalize buildFile for re-import detection
+		if (buildModule != null) {
+			buildModule = FileUtils.getFileUtils().normalize(
+					buildModule.getAbsolutePath());
+			project.setNewProperty(EasyAntMagicNames.EASYANT_FILE, buildModule
+					.getAbsolutePath());
+
+		}
+
+		if (buildFile != null) {
+			buildFile = FileUtils.getFileUtils().normalize(
+					buildFile.getAbsolutePath());
+			project.setNewProperty(MagicNames.ANT_FILE, buildFile
+					.getAbsolutePath());
+
+		}
+
+		configuration.setBuildFile(buildFile);
+		configuration.setBuildModule(buildModule);
+
+		// Emulate an empty project
+		// import task check that projectHelper is at toplevel by checking the
+		// size of projectHelper.getImportTask()
+		ProjectHelper helper = ProjectHelper.getProjectHelper();
+		File mainscript = null;
+		try {
+			mainscript = File.createTempFile(
+					EasyAntConstants.EASYANT_TASK_NAME, null);
+			mainscript.deleteOnExit();
+		} catch (IOException e1) {
+			throw new BuildException("Can't create temp file", e1);
+		}
+
+		Location mainscriptLocation = new Location(mainscript.toString());
+		helper.getImportStack().addElement(mainscript);
+		project.addReference(ProjectHelper.PROJECTHELPER_REFERENCE, helper);
+
+		// Used to emulate top level target
+		Target topLevel = new Target();
+		topLevel.setName("");
+
+		// Validate Phase is used by several system plugin so we should
+		// initialize it
+		Phase validatePhase = new Phase();
+		validatePhase.setName("validate");
+		validatePhase
+				.setDescription("validate the project is correct and all necessary information is available");
+		project.addTarget("validate", validatePhase);
+
+		Ivy easyantIvyInstance = configureEasyAntIvyInstance(project);
+		configurePluginService(project, easyantIvyInstance);
+
+		// Profile
+		if (configuration.getActiveBuildConfigurations().size() != 0) {
+			String buildConfigurations = null;
+			for (String conf : configuration.getActiveBuildConfigurations()) {
+				if (buildConfigurations == null) {
+					buildConfigurations = conf;
+				} else {
+					buildConfigurations = buildConfigurations + "," + conf;
+				}
+
+			}
+			project.log("Active build configurations : " + buildConfigurations,
+					Project.MSG_INFO);
+			project.setProperty(EasyAntMagicNames.ACTIVE_BUILD_CONFIGURATIONS,
+					buildConfigurations);
+		}
+
+		// Load system plugins
+		if (configuration.getSystemPlugins().size() > 0) {
+			project.log("Loading System Plugins...");
+		}
+		for (PluginDescriptor systemPlugin : configuration.getSystemPlugins()) {
+			// import/include system plugin
+			Import importTask = new Import();
+			importTask.setMrid(systemPlugin.getMrid());
+			importTask.setOrganisation(systemPlugin.getOrganisation());
+			importTask.setModule(systemPlugin.getModule());
+			importTask.setRevision(systemPlugin.getRevision());
+			importTask.setAs(systemPlugin.getAs());
+			importTask.setMode(systemPlugin.getMode());
+			importTask.setMandatory(systemPlugin.isMandatory());
+			importTask.setProject(project);
+			importTask.setTaskName(EasyAntConstants.EASYANT_TASK_NAME);
+			importTask.setOwningTarget(topLevel);
+			importTask.setLocation(mainscriptLocation);
+			importTask.execute();
+		}
+
+		if (configuration.getBuildModule() != null
+				|| configuration.getBuildFile() != null) {
+			LoadModule lm = new LoadModule();
+			lm.setBuildModule(configuration.getBuildModule());
+			lm.setBuildFile(configuration.getBuildFile());
+			lm.setTaskName(EasyAntConstants.EASYANT_TASK_NAME);
+			lm.setProject(project);
+			lm.setOwningTarget(topLevel);
+			lm.setLocation(mainscriptLocation);
+			lm.execute();
+		}
+	}
+
+	/**
+	 * this method run the build process
+	 * 
+	 * @throws BuildException
+	 */
+	public void doBuild() throws BuildException {
+		final Project project = new Project();
+		project.fireBuildStarted();
+
+		Throwable error = null;
+
+		try {
+
+			PrintStream savedErr = System.err;
+			PrintStream savedOut = System.out;
+			InputStream savedIn = System.in;
+
+			// use a system manager that prevents from System.exit()
+			SecurityManager oldsm = null;
+			oldsm = System.getSecurityManager();
+
+			// SecurityManager can not be installed here for backwards
+			// compatibility reasons (PD). Needs to be loaded prior to
+			// ant class if we are going to implement it.
+			// System.setSecurityManager(new NoExitSecurityManager());
+			try {
+				if (configuration.isAllowInput()) {
+					project.setDefaultInputStream(System.in);
+				}
+				System.setIn(new DemuxInputStream(project));
+				System.setOut(new PrintStream(new DemuxOutputStream(project,
+						false)));
+				System.setErr(new PrintStream(new DemuxOutputStream(project,
+						true)));
+				configureProject(project);
+				initProject(project);
+
+				// make sure that we have a target to execute
+				if (configuration.getTargets().size() == 0) {
+					if (project.getDefaultTarget() != null) {
+						configuration.getTargets().addElement(
+								project.getDefaultTarget());
+					}
+				}
+
+				project.executeTargets(configuration.getTargets());
+			} finally {
+				// put back the original security manager
+				// The following will never eval to true. (PD)
+				if (oldsm != null) {
+					System.setSecurityManager(oldsm);
+				}
+
+				System.setOut(savedOut);
+				System.setErr(savedErr);
+				System.setIn(savedIn);
+			}
+		} catch (RuntimeException exc) {
+			error = exc;
+			throw exc;
+		} catch (Error e) {
+			error = e;
+			throw e;
+		} finally {
+			try {
+				project.fireBuildFinished(error);
+			} catch (Throwable t) {
+				// yes, I know it is bad style to catch Throwable,
+				// but if we don't, we lose valuable information
+				System.err.println("Caught an exception while logging the"
+						+ " end of the build.  Exception was:");
+				t.printStackTrace();
+				if (error != null) {
+					System.err.println("There has been an error prior to"
+							+ " that:");
+					error.printStackTrace();
+				}
+				throw new BuildException(t);
+			}
+		}
+		if (configuration.isShowMemoryDetails()
+				|| configuration.getMsgOutputLevel() >= Project.MSG_VERBOSE) {
+			printMemoryDetails(project);
+		}
+
+	}
+
+	/**
+	 * This is a static method used to run build process
+	 * 
+	 * @param eaConfig
+	 *            an easyant configuration
+	 * @throws BuildException
+	 */
+	public static void runBuild(EasyAntConfiguration eaConfig)
+			throws BuildException {
+		EasyAntEngine eaEngine = new EasyAntEngine(eaConfig);
+		eaEngine.doBuild();
+	}
+
+	/**
+	 * This is a static method used to configure and initialize an existing
+	 * project
+	 * 
+	 * @param project
+	 *            a given project
+	 * @param eaConfiguration
+	 *            an easyant configuration
+	 * @return configured project
+	 * @throws BuildException
+	 */
+	public static Project configureAndInitProject(Project project,
+			EasyAntConfiguration eaConfiguration) throws BuildException {
+		EasyAntEngine eaEngine = new EasyAntEngine(eaConfiguration);
+		eaEngine.configureProject(project);
+		eaEngine.initProject(project);
+		return project;
+	}
+
+	/**
+	 * Print memory details
+	 * 
+	 * @param project
+	 *            a given project
+	 */
+	public static void printMemoryDetails(Project project) {
+		project.log("---- Memory Details ----");
+		project.log("  Used Memory  = "
+				+ (Runtime.getRuntime().totalMemory() / MEGABYTE - Runtime
+						.getRuntime().freeMemory()
+						/ MEGABYTE) + "MB");
+		project.log("  Free Memory  = "
+				+ (Runtime.getRuntime().freeMemory() / MEGABYTE) + "MB");
+		project.log("  Total Memory = "
+				+ (Runtime.getRuntime().totalMemory() / MEGABYTE) + "MB");
+		project.log("-----------------------");
+	}
+
+	/**
+	 * Return the configured plugin service instance
+	 * 
+	 * @return the configured plugin service instance
+	 */
+	public PluginService getPluginService() {
+		// hack for IDE integration
+		if (pluginService == null) {
+			Project project = new Project();
+			project.setCoreLoader(configuration.getCoreLoader());
+			Enumeration<?> e = configuration.getDefinedProps().keys();
+			while (e.hasMoreElements()) {
+				String arg = (String) e.nextElement();
+				String value = (String) configuration.getDefinedProps()
+						.get(arg);
+				project.setUserProperty(arg, value);
+			}
+			project.setName("EasyAnt");
+			// not sure we need to invoke init here
+			project.init();
+			Ivy ivy = configureEasyAntIvyInstance(project);
+			configurePluginService(project, ivy);
+		}
+		return pluginService;
+	}
+
+	/**
+	 * Cache of the EasyAnt version information when it has been loaded.
+	 */
+	private static String easyantVersion = null;
+
+	/**
+	 * Returns the EasyAnt version information, if available. Once the
+	 * information has been loaded once, it's cached and returned from the cache
+	 * on future calls.
+	 * 
+	 * @return the Ant version information as a String (always non-
+	 *         <code>null</code>)
+	 * 
+	 * @exception BuildException
+	 *                if the version information is unavailable
+	 */
+	public static String getEasyAntVersion() {
+
+		if (easyantVersion == null) {
+			try {
+				Properties props = new Properties();
+				InputStream in = Main.class
+						.getResourceAsStream("/META-INF/version.properties");
+				props.load(in);
+				in.close();
+
+				StringBuffer msg = new StringBuffer();
+				msg.append("EasyAnt version ");
+				msg.append(props.getProperty("VERSION"));
+				msg.append(" compiled on ");
+				msg.append(props.getProperty("DATE"));
+				easyantVersion = msg.toString();
+			} catch (IOException ioe) {
+				throw new BuildException(
+						"Could not load the version information:"
+								+ ioe.getMessage());
+			} catch (NullPointerException npe) {
+				throw new BuildException(
+						"Could not load the version information.");
+			}
+		}
+		return easyantVersion;
+	}
+
+}

Propchange: incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/EasyAntEngine.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/EasyAntEngine.java
------------------------------------------------------------------------------
    svn:executable = *

Propchange: incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/EasyAntEngine.java
------------------------------------------------------------------------------
    svn:keywords = Date Revision Author HeadURL Id

Propchange: incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/EasyAntEngine.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain

Added: incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/EasyAntMagicNames.java
URL: http://svn.apache.org/viewvc/incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/EasyAntMagicNames.java?rev=1071697&view=auto
==============================================================================
--- incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/EasyAntMagicNames.java (added)
+++ incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/EasyAntMagicNames.java Thu Feb 17 17:01:07 2011
@@ -0,0 +1,187 @@
+/* 
+ *  Copyright 2008-2010 the EasyAnt project
+ * 
+ *  See the NOTICE file distributed with this work for additional information
+ *  regarding copyright ownership. 
+ * 
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ * 
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ *  Unless required by applicable law or agreed to in writing, software 
+ *  distributed under the License is distributed on an "AS IS" BASIS, 
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and 
+ *  limitations under the License.
+ */
+package org.apache.easyant.core;
+
+import org.apache.easyant.tasks.CoreRevisionCheckerTask;
+
+/**
+ * Magic names used within EasyAnt.
+ * 
+ * Not all magic names are here yet.
+ * 
+ * s
+ */
+public interface EasyAntMagicNames {
+
+	/**
+	 * property for easyant file name. Value: {@value}
+	 */
+	public static final String EASYANT_FILE = "easyant.file";
+
+	/**
+	 * Name the default ivy instance name used by easyant Value: {@value}
+	 */
+	public static final String EASYANT_IVY_INSTANCE = "easyant.ivy.instance";
+
+	/**
+	 * Name of directory to store EasyAnt modules Value: {@value}
+	 */
+	public static final String EASYANT_MODULES_DIR = "easyant.modules.dir";
+
+	/**
+	 * Name the default ivy instance name used by projects Value: {@value}
+	 */
+	public static final String PROJECT_IVY_INSTANCE = "project.ivy.instance";
+
+	/**
+	 * Name of the property that contains the project ivy setting file Value: *
+	 * {@value}
+	 */
+	public static final String PROJECT_IVY_SETTING_FILE = "project.ivy.settings.file";
+
+	/**
+	 * Name of the property that contains the project ivy setting url Value: *
+	 * {@value}
+	 */
+	public static final String PROJECT_IVY_SETTING_URL = "project.ivy.settings.url";
+
+	/**
+	 * Name of the property that contains active build configuration Value: *
+	 * {@value}
+	 */
+	public static final String ACTIVE_BUILD_CONFIGURATIONS = "active.build.configurations";
+
+	/**
+	 * Name of the property that contains all active build configuration for the
+	 * current project Value: {@value}
+	 */
+	public static final String MAIN_CONFS = "main.confs";
+
+	/**
+	 * Name of the property that contains build configuration available in
+	 * current project Value: {@value}
+	 */
+	public static final String AVAILABLE_BUILD_CONFIGURATIONS = "available.build.configurations";
+
+	/**
+	 * Property name used to disable core revision check if this property is set
+	 * to true it means that corerevision checker feature will be disabled.
+	 * Value: {@value}
+	 * 
+	 * @see CoreRevisionCheckerTask
+	 */
+	public static final String SKIP_CORE_REVISION_CHECKER = "skip.corerevision.checker";
+
+	/**
+	 * Property name containing the target directory Value: {@value}
+	 */
+	public static final String TARGET = "target";
+
+	/**
+	 * Name of the plugin service instance Value: {@value}
+	 */
+	public static final String PLUGIN_SERVICE_INSTANCE = "plugin.service.instance";
+
+	/**
+	 * Name of the property containing the default location of ivysettings file
+	 * used by easyant ivy instance Value: {@value}
+	 */
+	public static final String EASYANT_DEFAULT_IVYSETTINGS = "easyant.default.ivysettings.url";
+
+	/**
+	 * Name of the property containing the default location of ivysettings file
+	 * used by easyant ivy instance with extra modules Value: {@value}
+	 */
+	public static final String EASYANT_EXTRA_IVYSETTINGS = "easyant.extra.ivysettings.url";
+
+	/**
+	 * Name of the property containing the default location of ivysettings file
+	 * used by project ivy instance Value: {@value}
+	 */
+	public static final String PROJECT_DEFAULT_IVYSETTINGS = "project.default.ivysettings.url";
+
+	/**
+	 * Name of the property containing the easyant core repository Value:
+	 * {@value}
+	 */
+	public static final String EASYANT_CORE_REPO_URL = "easyant.core.repo.url";
+
+	/**
+	 * Name of the property containing the easyant extra repository Value:
+	 * {@value}
+	 */
+	public static final String EASYANT_EXTRA_REPO_URL = "easyant.extramodules.repo.url";
+
+	/**
+	 * Name of the property containing the log stategy for easyant modules
+	 * Value: {@value}
+	 */
+	public static final String MODULE_DOWNLOAD_LOG = "easyant.modules.download.log";
+
+	/**
+	 * Name of the property containing the build-scoped repository name, if
+	 * configured Value: {@value}
+	 */
+	public static final String EASYANT_BUILD_REPOSITORY = "easyant.build.repository";
+
+	public static final String META_TARGET = "meta.target";
+
+	/**
+	 * Name of the property containing the appended to menu generator registry
+	 * references Value: {@value}
+	 */
+	public static final String MENU_GENERATOR_REGISTRY_REF = "menugen.ref";
+
+	/**
+	 * Name of the property containing pre module targets. In a multi project
+	 * context, those targets will be executed before delagating to subprojects.
+	 * Value : {@value}
+	 */
+	public static final String PRE_MODULE_TARGETS = "pre.module.targets";
+
+	/**
+	 * Name of the property containing path to user easyant ivysettings file
+	 * Value: {@value}
+	 */
+	public static final String USER_EASYANT_IVYSETTINGS = "user.easyant.ivysettings.file";
+
+	/**
+	 * Name of the property containing path to global easyant ivysettings file
+	 * Value: {@value}
+	 */
+	public static final String GLOBAL_EASYANT_IVYSETTINGS = "global.easyant.ivysettings.file";
+	
+	/**
+	 * Name of the property specifyinf if build repository should be used
+	 * Value: {@value}
+	 */
+	public static final String USE_BUILD_REPOSITORY = "use.build.repository";
+
+    /**
+     * property for easyant offline mode. Value: {@value}
+     */
+    public static final String EASYANT_OFFLINE = "easyant.offline";
+
+    /**
+     * Property specifying if user ivysettings should be ignored
+     * Value: {@value}
+     */
+	public static final String IGNORE_USER_IVYSETTINGS = "ignore.user.ivysettings";
+
+}

Propchange: incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/EasyAntMagicNames.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/EasyAntMagicNames.java
------------------------------------------------------------------------------
    svn:keywords = Date Revision Author HeadURL Id

Propchange: incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/EasyAntMagicNames.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain

Added: incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/EasyAntMain.java
URL: http://svn.apache.org/viewvc/incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/EasyAntMain.java?rev=1071697&view=auto
==============================================================================
--- incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/EasyAntMain.java (added)
+++ incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/EasyAntMain.java Thu Feb 17 17:01:07 2011
@@ -0,0 +1,1010 @@
+/* 
+ *  Copyright 2008-2010 the EasyAnt project
+ * 
+ *  See the NOTICE file distributed with this work for additional information
+ *  regarding copyright ownership. 
+ * 
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ * 
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ *  Unless required by applicable law or agreed to in writing, software 
+ *  distributed under the License is distributed on an "AS IS" BASIS, 
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and 
+ *  limitations under the License.
+ */
+
+package org.apache.easyant.core;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintStream;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+import java.util.Vector;
+
+import org.apache.easyant.core.ant.Phase;
+import org.apache.easyant.core.factory.EasyantConfigurationFactory;
+import org.apache.easyant.man.ProjectMan;
+import org.apache.tools.ant.BuildException;
+import org.apache.tools.ant.DemuxInputStream;
+import org.apache.tools.ant.DemuxOutputStream;
+import org.apache.tools.ant.Diagnostics;
+import org.apache.tools.ant.ExitStatusException;
+import org.apache.tools.ant.Main;
+import org.apache.tools.ant.Project;
+import org.apache.tools.ant.Target;
+import org.apache.tools.ant.launch.AntMain;
+import org.apache.tools.ant.util.FileUtils;
+
+/**
+ * Command line entry point into EasyAnt. This class is entered via the
+ * canonical `public static void main` entry point and reads the command line
+ * arguments. It then assembles and executes an Ant project.
+ * <p>
+ * If you integrating EasyAnt into some other tool, this is not the class to use
+ * as an entry point. Instead you should have a look at {@link EasyAntEngine}.
+ * </p>
+ */
+public class EasyAntMain implements AntMain {
+	/**
+	 * A Set of args are are handled by the launcher and should not be seen by
+	 * Main.
+	 */
+	private static final Set LAUNCH_COMMANDS = new HashSet();
+	private boolean isLogFileUsed;
+	static {
+		LAUNCH_COMMANDS.add("-lib");
+		LAUNCH_COMMANDS.add("-cp");
+		LAUNCH_COMMANDS.add("-noclasspath");
+		LAUNCH_COMMANDS.add("--noclasspath");
+		LAUNCH_COMMANDS.add("-nouserlib");
+		LAUNCH_COMMANDS.add("-main");
+	}
+	private EasyAntConfiguration easyAntConfiguration;
+	private boolean projectHelp;
+	private boolean projectMan;
+
+	private ProjectMan man;
+	
+	/**
+	 * Whether or not this instance has successfully been constructed and is
+	 * ready to run.
+	 */
+	private boolean readyToRun;
+	private Vector propertyFiles = new Vector(1);
+	private File buildFile;
+	private File buildModule;
+	private File easyantConfFile;
+	private String buildConf;
+
+	/**
+	 * Prints the message of the Throwable if it (the message) is not
+	 * <code>null</code>.
+	 * 
+	 * @param t
+	 *            Throwable to print the message of. Must not be
+	 *            <code>null</code>.
+	 */
+	private static void printMessage(Throwable t) {
+		String message = t.getMessage();
+		if (message != null) {
+			System.err.println(message);
+		}
+	}
+
+	/**
+	 * Creates a new instance of this class using the arguments specified, gives
+	 * it any extra user properties which have been specified, and then runs the
+	 * build using the classloader provided.
+	 * 
+	 * @param args
+	 *            Command line arguments. Must not be <code>null</code>.
+	 * @param additionalUserProperties
+	 *            Any extra properties to use in this build. May be
+	 *            <code>null</code>, which is the equivalent to passing in an
+	 *            empty set of properties.
+	 * @param coreLoader
+	 *            Classloader used for core classes. May be <code>null</code> in
+	 *            which case the system classloader is used.
+	 */
+	public static void start(String[] args,
+			Properties additionalUserProperties, ClassLoader coreLoader) {
+		EasyAntMain m = new EasyAntMain();
+		m.startAnt(args, additionalUserProperties, coreLoader);
+	}
+
+	/**
+	 * Start Ant
+	 * 
+	 * @param args
+	 *            command line args
+	 * @param additionalUserProperties
+	 *            properties to set beyond those that may be specified on the
+	 *            args list
+	 * @param coreLoader
+	 *            - not used
+	 * 
+	 * @since Ant 1.6
+	 */
+	public void startAnt(String[] args, Properties additionalUserProperties,
+			ClassLoader coreLoader) {
+		easyAntConfiguration.setCoreLoader(coreLoader);
+		try {
+			Diagnostics.validateVersion();
+			processArgs(args);
+		} catch (Throwable exc) {
+			if (easyAntConfiguration.getMsgOutputLevel() >= Project.MSG_VERBOSE) {
+				exc.printStackTrace();
+			} 
+			handleLogfile();
+			printMessage(exc);
+			exit(1);
+			return;
+		}
+
+		if (additionalUserProperties != null) {
+			for (Enumeration e = additionalUserProperties.keys(); e
+					.hasMoreElements();) {
+				String key = (String) e.nextElement();
+				String property = additionalUserProperties.getProperty(key);
+				easyAntConfiguration.getDefinedProps().put(key, property);
+			}
+		}
+
+		// expect the worst
+		int exitCode = 1;
+		try {
+			try {
+				runBuild(coreLoader);
+				exitCode = 0;
+			} catch (ExitStatusException ese) {
+				exitCode = ese.getStatus();
+				if (exitCode != 0) {
+					throw ese;
+				}
+			}
+		} catch (BuildException be) {
+			if (easyAntConfiguration.getErr() != System.err) {
+				printMessage(be);
+			}
+		} catch (Throwable exc) {
+			exc.printStackTrace();
+			printMessage(exc);
+		} finally {
+			handleLogfile();
+		}
+		exit(exitCode);
+	}
+
+	/**
+	 * This operation is expected to call {@link System#exit(int)}, which is
+	 * what the base version does. However, it is possible to do something else.
+	 * 
+	 * @param exitCode
+	 *            code to exit with
+	 */
+	protected void exit(int exitCode) {
+		System.exit(exitCode);
+	}
+
+	/**
+	 * Close logfiles, if we have been writing to them.
+	 * 
+	 * @since Ant 1.6
+	 */
+	private void handleLogfile() {
+		if (isLogFileUsed && easyAntConfiguration != null) {
+			FileUtils.close(easyAntConfiguration.getOut());
+			FileUtils.close(easyAntConfiguration.getErr());
+		}
+	}
+
+	/**
+	 * Command line entry point. This method kicks off the building of a project
+	 * object and executes a build using either a given target or the default
+	 * target.
+	 * 
+	 * @param args
+	 *            Command line arguments. Must not be <code>null</code>.
+	 */
+	public static void main(String[] args) {
+		start(args, null, null);
+	}
+
+	/**
+	 * Constructor used when creating Main for later arg processing and startup
+	 */
+	public EasyAntMain() {
+		easyAntConfiguration = EasyantConfigurationFactory.getInstance()
+				.createDefaultConfiguration();
+	}
+
+	/**
+	 * Process command line arguments. When ant is started from Launcher,
+	 * launcher-only arguments do not get passed through to this routine.
+	 * 
+	 * @param args
+	 *            the command line arguments.
+	 * 
+	 * @since Ant 1.6
+	 */
+	private void processArgs(String[] args) {
+		String searchForThis = null;
+		PrintStream logTo = null;
+
+		// cycle through given args
+
+		boolean justPrintUsage = false;
+		boolean justPrintVersion = false;
+		boolean justPrintDiagnostics = false;
+
+		for (int i = 0; i < args.length; i++) {
+			String arg = args[i];
+
+			if (arg.equals("-help") || arg.equals("-h")) {
+				justPrintUsage = true;
+			} else if (arg.equals("-version")) {
+				justPrintVersion = true;
+			} else if (arg.equals("-showMemoryDetails")) {
+				easyAntConfiguration.setShowMemoryDetails(true);
+			} else if (arg.equals("-diagnostics")) {
+				justPrintDiagnostics = true;
+			} else if (arg.equals("-quiet") || arg.equals("-q")) {
+				easyAntConfiguration.setMsgOutputLevel(Project.MSG_WARN);
+			} else if (arg.equals("-verbose") || arg.equals("-v")) {
+				easyAntConfiguration.setMsgOutputLevel(Project.MSG_VERBOSE);
+			} else if (arg.equals("-debug") || arg.equals("-d")) {
+				easyAntConfiguration.setMsgOutputLevel(Project.MSG_DEBUG);
+			} else if (arg.equals("-noinput")) {
+				easyAntConfiguration.setAllowInput(false);
+			} else if (arg.equals("-logfile") || arg.equals("-l")) {
+				try {
+					File logFile = new File(args[i + 1]);
+					i++;
+					logTo = new PrintStream(new FileOutputStream(logFile));
+					isLogFileUsed = true;
+				} catch (IOException ioe) {
+					String msg = "Cannot write on the specified log file. "
+							+ "Make sure the path exists and you have write "
+							+ "permissions.";
+					throw new BuildException(msg);
+				} catch (ArrayIndexOutOfBoundsException aioobe) {
+					String msg = "You must specify a log file when "
+							+ "using the -log argument";
+					throw new BuildException(msg);
+				}
+			} else if (arg.equals("-buildmodule") || arg.equals("-file")
+					|| arg.equals("-f")) {
+				i = handleArgBuildModule(args, i);
+				easyAntConfiguration.setBuildModule(buildModule);
+			} else if (arg.equals("-buildfile")) {
+				i = handleArgBuildFile(args, i);
+				easyAntConfiguration.setBuildFile(buildFile);
+			} else if (arg.equals("-buildconf") || arg.equals("-C")) {
+				i = handleArgBuildConf(args,i);
+				easyAntConfiguration.getActiveBuildConfigurations().add(buildConf);
+			} else if (arg.equals("-config-file")) {
+				i = handleArgEasyAntConf(args, i);
+				try {
+					easyAntConfiguration = EasyantConfigurationFactory
+							.getInstance().createConfigurationFromFile(
+									easyAntConfiguration,
+									easyantConfFile.toURL());
+				} catch (Exception e) {
+					throw new BuildException(e);
+				}
+			} else if (arg.equals("-listener")) {
+				i = handleArgListener(args, i);
+			} else if (arg.startsWith("-D")) {
+				i = handleArgDefine(args, i);
+			} else if (arg.equals("-logger")) {
+				i = handleArgLogger(args, i);
+			} else if (arg.equals("-inputhandler")) {
+				i = handleArgInputHandler(args, i);
+			} else if (arg.equals("-emacs") || arg.equals("-e")) {
+				easyAntConfiguration.setEmacsMode(true);
+			} else if (arg.equals("-listTargets")
+					|| arg.equals("-describe")
+					|| arg.equals("-listProps")
+					|| arg.equals("-listPhases")
+					|| arg.equals("-listPlugins")) {
+				projectMan = true;
+				man = new ProjectMan();
+				man.setCommand(arg);
+				if(i < args.length-1 && !args[i+1].startsWith("-")) {
+					man.addParam(args[++i]);
+				}
+			} else if(arg.equals("-projecthelp")
+					|| arg.equals("-p")) {
+				// set the flag to display the targets and quit
+				projectHelp = true;
+			} else if (arg.equals("-find") || arg.equals("-s")) {
+				// eat up next arg if present, default to module.ivy
+				if (i < args.length - 1) {
+					searchForThis = args[++i];
+
+				} else {
+					searchForThis = EasyAntConstants.DEFAULT_BUILD_MODULE;
+				}
+				easyAntConfiguration.setBuildModule(new File(searchForThis));
+				easyAntConfiguration.setBuildModuleLookupEnabled(true);
+			} else if (arg.startsWith("-propertyfile")) {
+				i = handleArgPropertyFile(args, i);
+			} else if (arg.equals("-k") || arg.equals("-keep-going")) {
+				easyAntConfiguration.setKeepGoingMode(true);
+            } else if (arg.equals("-offline") || arg.equals("-o")) {
+                easyAntConfiguration.setOffline(true);
+			} else if (arg.equals("-nice")) {
+				i = handleArgNice(args, i);
+			} else if (LAUNCH_COMMANDS.contains(arg)) {
+				// catch script/ant mismatch with a meaningful message
+				// we could ignore it, but there are likely to be other
+				// version problems, so we stamp down on the configuration now
+				String msg = "Ant's Main method is being handed "
+						+ "an option " + arg
+						+ " that is only for the launcher class."
+						+ "\nThis can be caused by a version mismatch between "
+						+ "the ant script/.bat file and Ant itself.";
+				throw new BuildException(msg);
+			} else if (arg.equals("-autoproxy")) {
+				easyAntConfiguration.setProxy(true);
+			} else if (arg.startsWith("-")) {
+				// we don't have any more args to recognize!
+				String msg = "Unknown argument: " + arg;
+				System.err.println(msg);
+				printUsage();
+				throw new BuildException("");
+			} else {
+				easyAntConfiguration.getTargets().addElement(arg);
+			}
+		}
+
+		if (easyAntConfiguration.getMsgOutputLevel() >= Project.MSG_VERBOSE
+				|| justPrintVersion) {
+			printVersion(easyAntConfiguration.getMsgOutputLevel());
+		}
+
+		if (justPrintUsage || justPrintVersion || justPrintDiagnostics) {
+			if (justPrintUsage) {
+				printUsage();
+			}
+			if (justPrintDiagnostics) {
+				Diagnostics.doReport(System.out, easyAntConfiguration
+						.getMsgOutputLevel());
+			}
+			return;
+		}
+
+		// Load the property files specified by -propertyfile
+		loadPropertyFiles();
+
+		if (logTo != null) {
+			easyAntConfiguration.setOut(logTo);
+			easyAntConfiguration.setErr(logTo);
+			System.setOut(easyAntConfiguration.getOut());
+			System.setErr(easyAntConfiguration.getErr());
+		}
+		readyToRun = true;
+	}
+
+	// --------------------------------------------------------
+	// Methods for handling the command line arguments
+	// --------------------------------------------------------
+
+	/** Handle the -buildfile, -file, -f argument */
+	private int handleArgBuildFile(String[] args, int pos) {
+		try {
+			buildFile = new File(args[++pos].replace('/', File.separatorChar));
+			++pos;
+		} catch (ArrayIndexOutOfBoundsException aioobe) {
+			throw new BuildException(
+					"You must specify a buildfile when using the -buildfile argument");
+		}
+		return pos;
+	}
+
+	private int handleArgBuildModule(String[] args, int pos) {
+		try {
+			buildModule = new File(args[++pos].replace('/', File.separatorChar));
+		} catch (ArrayIndexOutOfBoundsException aioobe) {
+			throw new BuildException(
+					"You must specify a buildfile when using the -buildmodule argument");
+		}
+		return pos;
+	}
+	
+	private int handleArgBuildConf(String[] args, int pos) {
+		try {
+			buildConf = args[++pos];
+		} catch (ArrayIndexOutOfBoundsException aioobe) {
+			throw new BuildException(
+					"You must specify a build configuration when using the -buildconf argument");
+		}
+		return pos;
+	}
+
+	/** Handle -config-file argument */
+	private int handleArgEasyAntConf(String[] args, int pos) {
+		try {
+			easyantConfFile = new File(args[++pos].replace('/',
+					File.separatorChar));
+		} catch (ArrayIndexOutOfBoundsException aioobe) {
+			throw new BuildException(
+					"You must specify an easyant ivy configuration when using the -easyantivyconf argument");
+		}
+		return pos;
+	}
+
+	/** Handle -listener argument */
+	private int handleArgListener(String[] args, int pos) {
+		try {
+			easyAntConfiguration.getListeners().addElement(args[pos + 1]);
+			pos++;
+		} catch (ArrayIndexOutOfBoundsException aioobe) {
+			String msg = "You must specify a classname when "
+					+ "using the -listener argument";
+			throw new BuildException(msg);
+		}
+		return pos;
+	}
+
+	/** Handler -D argument */
+	private int handleArgDefine(String[] args, int argPos) {
+		/*
+		 * Interestingly enough, we get to here when a user uses -Dname=value.
+		 * However, in some cases, the OS goes ahead and parses this out to args
+		 * {"-Dname", "value"} so instead of parsing on "=", we just make the
+		 * "-D" characters go away and skip one argument forward.
+		 * 
+		 * I don't know how to predict when the JDK is going to help or not, so
+		 * we simply look for the equals sign.
+		 */
+		String arg = args[argPos];
+		String name = arg.substring(2, arg.length());
+		String value = null;
+		int posEq = name.indexOf("=");
+		if (posEq > 0) {
+			value = name.substring(posEq + 1);
+			name = name.substring(0, posEq);
+		} else if (argPos < args.length - 1) {
+			value = args[++argPos];
+		} else {
+			throw new BuildException("Missing value for property " + name);
+		}
+		easyAntConfiguration.getDefinedProps().put(name, value);
+		return argPos;
+	}
+
+	/** Handle the -logger argument. */
+	private int handleArgLogger(String[] args, int pos) {
+		if (easyAntConfiguration.getLoggerClassname() != null) {
+			throw new BuildException("Only one logger class may be specified.");
+		}
+		try {
+			easyAntConfiguration.setLoggerClassname(args[++pos]);
+		} catch (ArrayIndexOutOfBoundsException aioobe) {
+			throw new BuildException(
+					"You must specify a classname when using the -logger argument");
+		}
+		return pos;
+	}
+
+	/** Handle the -inputhandler argument. */
+	private int handleArgInputHandler(String[] args, int pos) {
+		if (easyAntConfiguration.getInputHandlerClassname() != null) {
+			throw new BuildException("Only one input handler class may "
+					+ "be specified.");
+		}
+		try {
+			easyAntConfiguration.setInputHandlerClassname(args[++pos]);
+		} catch (ArrayIndexOutOfBoundsException aioobe) {
+			throw new BuildException("You must specify a classname when"
+					+ " using the -inputhandler" + " argument");
+		}
+		return pos;
+	}
+
+	/** Handle the -propertyfile argument. */
+	private int handleArgPropertyFile(String[] args, int pos) {
+		try {
+			propertyFiles.addElement(args[++pos]);
+		} catch (ArrayIndexOutOfBoundsException aioobe) {
+			String msg = "You must specify a property filename when "
+					+ "using the -propertyfile argument";
+			throw new BuildException(msg);
+		}
+		return pos;
+	}
+
+	/** Handle the -nice argument. */
+	private int handleArgNice(String[] args, int pos) {
+		try {
+			easyAntConfiguration.setThreadPriority(Integer.decode(args[++pos]));
+		} catch (ArrayIndexOutOfBoundsException aioobe) {
+			throw new BuildException("You must supply a niceness value (1-10)"
+					+ " after the -nice option");
+		} catch (NumberFormatException e) {
+			throw new BuildException("Unrecognized niceness value: "
+					+ args[pos]);
+		}
+
+		if (easyAntConfiguration.getThreadPriority().intValue() < Thread.MIN_PRIORITY
+				|| easyAntConfiguration.getThreadPriority().intValue() > Thread.MAX_PRIORITY) {
+			throw new BuildException("Niceness value is out of the range 1-10");
+		}
+		return pos;
+	}
+
+	// --------------------------------------------------------
+	// other methods
+	// --------------------------------------------------------
+
+	/** Load the property files specified by -propertyfile */
+	private void loadPropertyFiles() {
+		for (int propertyFileIndex = 0; propertyFileIndex < propertyFiles
+				.size(); propertyFileIndex++) {
+			String filename = (String) propertyFiles
+					.elementAt(propertyFileIndex);
+			Properties props = new Properties();
+			FileInputStream fis = null;
+			try {
+				fis = new FileInputStream(filename);
+				props.load(fis);
+			} catch (IOException e) {
+				System.out.println("Could not load property file " + filename
+						+ ": " + e.getMessage());
+			} finally {
+				FileUtils.close(fis);
+			}
+
+			// ensure that -D properties take precedence
+			Enumeration propertyNames = props.propertyNames();
+			while (propertyNames.hasMoreElements()) {
+				String name = (String) propertyNames.nextElement();
+				if (easyAntConfiguration.getDefinedProps().getProperty(name) == null) {
+					easyAntConfiguration.getDefinedProps().put(name,
+							props.getProperty(name));
+				}
+			}
+		}
+	}
+
+	/**
+	 * Executes the build. If the constructor for this instance failed (e.g.
+	 * returned after issuing a warning), this method returns immediately.
+	 * 
+	 * @param coreLoader
+	 *            The classloader to use to find core classes. May be
+	 *            <code>null</code>, in which case the system classloader is
+	 *            used.
+	 * 
+	 * @exception BuildException
+	 *                if the build fails
+	 */
+	private void runBuild(ClassLoader coreLoader) throws BuildException {
+		Project project = new Project();
+		if (!readyToRun) {
+			return;
+		}
+		if (projectHelp) {
+			displayProjectHelp();
+		} else if(projectMan) {
+			EasyAntEngine.configureAndInitProject(project, easyAntConfiguration);
+			File moduleDescriptor =new File(project.getProperty(EasyAntMagicNames.EASYANT_FILE));
+			if (moduleDescriptor.exists()) {
+				man.setContext(project, moduleDescriptor);
+				man.execute();
+			} else {
+				project.log("Can't print project manual, there is no module descriptor available.");
+			}
+		} else {
+			EasyAntEngine.runBuild(easyAntConfiguration);
+		}
+
+	}
+
+	/**
+	 * Prints the description of a project (if there is one) to
+	 * <code>System.out</code>.
+	 * 
+	 * @param project
+	 *            The project to display a description of. Must not be
+	 *            <code>null</code>.
+	 */
+	protected void printDescription(Project project) {
+		if (project.getDescription() != null) {
+			project.log(project.getDescription());
+		}
+	}
+
+	/**
+	 * Targets in imported files with a project name and not overloaded by the
+	 * main build file will be in the target map twice. This method removes the
+	 * duplicate target.
+	 * 
+	 * @param targets
+	 *            the targets to filter.
+	 * @return the filtered targets.
+	 */
+	private static Map removeDuplicateTargets(Map targets) {
+		Map locationMap = new HashMap();
+		for (Iterator i = targets.entrySet().iterator(); i.hasNext();) {
+			Map.Entry entry = (Map.Entry) i.next();
+			String name = (String) entry.getKey();
+			Target target = (Target) entry.getValue();
+			Target otherTarget = (Target) locationMap.get(target.getLocation());
+			// Place this entry in the location map if
+			// a) location is not in the map
+			// b) location is in map, but it's name is longer
+			// (an imported target will have a name. prefix)
+			if (otherTarget == null
+					|| otherTarget.getName().length() > name.length()) {
+				locationMap.put(target.getLocation(), target); // Smallest name
+				// wins
+			}
+		}
+		Map ret = new HashMap();
+		for (Iterator i = locationMap.values().iterator(); i.hasNext();) {
+			Target target = (Target) i.next();
+			ret.put(target.getName(), target);
+		}
+		return ret;
+	}
+
+	/**
+	 * Searches for the correct place to insert a name into a list so as to keep
+	 * the list sorted alphabetically.
+	 * 
+	 * @param names
+	 *            The current list of names. Must not be <code>null</code>.
+	 * @param name
+	 *            The name to find a place for. Must not be <code>null</code>.
+	 * 
+	 * @return the correct place in the list for the given name
+	 */
+	private static int findTargetPosition(Vector names, String name) {
+		int res = names.size();
+		for (int i = 0; i < names.size() && res == names.size(); i++) {
+			if (name.compareTo((String) names.elementAt(i)) < 0) {
+				res = i;
+			}
+		}
+		return res;
+	}
+
+	/**
+	 * Writes a formatted list of target names to <code>System.out</code> with
+	 * an optional description.
+	 * 
+	 * 
+	 * @param project
+	 *            the project instance.
+	 * @param names
+	 *            The names to be printed. Must not be <code>null</code>.
+	 * @param descriptions
+	 *            The associated target descriptions. May be <code>null</code>,
+	 *            in which case no descriptions are displayed. If non-
+	 *            <code>null</code>, this should have as many elements as
+	 *            <code>names</code>.
+	 * @param heading
+	 *            The heading to display. Should not be <code>null</code>.
+	 * @param maxlen
+	 *            The maximum length of the names of the targets. If
+	 *            descriptions are given, they are padded to this position so
+	 *            they line up (so long as the names really <i>are</i> shorter
+	 *            than this).
+	 */
+	private static void printTargets(Project project, Vector names,
+			Vector descriptions, String heading, int maxlen) {
+		// now, start printing the targets and their descriptions
+		String lSep = System.getProperty("line.separator");
+		// got a bit annoyed that I couldn't find a pad function
+		String spaces = "    ";
+		while (spaces.length() <= maxlen) {
+			spaces += spaces;
+		}
+		StringBuffer msg = new StringBuffer();
+		msg.append(heading + lSep + lSep);
+		for (int i = 0; i < names.size(); i++) {
+			msg.append(" ");
+			msg.append(names.elementAt(i));
+			if (descriptions != null) {
+				msg.append(spaces.substring(0, maxlen
+						- ((String) names.elementAt(i)).length() + 2));
+				msg.append(descriptions.elementAt(i));
+			}
+			msg.append(lSep);
+		}
+		project.log(msg.toString(), Project.MSG_WARN);
+	}
+
+	/**
+	 * Prints a list of all targets in the specified project to
+	 * <code>System.out</code>, optionally including subtargets.
+	 * 
+	 * @param project
+	 *            The project to display a description of. Must not be
+	 *            <code>null</code>.
+	 * @param printSubTargets
+	 *            Whether or not subtarget names should also be printed.
+	 */
+	protected static void printTargets(Project project, boolean printSubTargets) {
+		// find the target with the longest name
+		int maxLength = 0;
+		Map ptargets = removeDuplicateTargets(project.getTargets());
+		String targetName;
+		String targetDescription;
+		Target currentTarget;
+		// split the targets in top-level and sub-targets depending
+		// on the presence of a description
+		Vector topNames = new Vector();
+		Vector topDescriptions = new Vector();
+		Vector subNames = new Vector();
+
+		Vector phases = new Vector();
+		Vector phasesDescriptions = new Vector();
+
+		for (Iterator i = ptargets.values().iterator(); i.hasNext();) {
+			currentTarget = (Target) i.next();
+			targetName = currentTarget.getName();
+			if (targetName.equals("")) {
+				continue;
+			}
+			targetDescription = currentTarget.getDescription();
+			// maintain a sorted list of targets
+			if (targetDescription == null) {
+				int pos = findTargetPosition(subNames, targetName);
+				subNames.insertElementAt(targetName, pos);
+			} else {
+				if (currentTarget instanceof Phase) {
+					int pos = findTargetPosition(phases, targetName);
+					phases.insertElementAt(targetName, pos);
+					phasesDescriptions.insertElementAt(targetDescription, pos);
+				} else {
+					int pos = findTargetPosition(topNames, targetName);
+					topNames.insertElementAt(targetName, pos);
+					topDescriptions.insertElementAt(targetDescription, pos);
+
+				}
+				if (targetName.length() > maxLength) {
+					maxLength = targetName.length();
+				}
+			}
+		}
+
+		printTargets(project, phases, phasesDescriptions, "Main phases:",
+				maxLength);
+		printTargets(project, topNames, topDescriptions, "Main targets:",
+				maxLength);
+		// if there were no main targets, we list all subtargets
+		// as it means nothing has a description
+		if (topNames.size() == 0) {
+			printSubTargets = true;
+		}
+		if (printSubTargets) {
+			printTargets(project, subNames, null, "Other targets:", 0);
+		}
+
+		String defaultTarget = project.getDefaultTarget();
+		if (defaultTarget != null && !"".equals(defaultTarget)) {
+			// shouldn't need to check but...
+			project.log("Default target: " + defaultTarget);
+		}
+	}
+
+	private void displayProjectHelp() {
+		final Project project = new Project();
+		Throwable error = null;
+
+		try {
+
+			PrintStream savedErr = System.err;
+			PrintStream savedOut = System.out;
+			InputStream savedIn = System.in;
+
+			// use a system manager that prevents from System.exit()
+			SecurityManager oldsm = null;
+			oldsm = System.getSecurityManager();
+
+			// SecurityManager can not be installed here for backwards
+			// compatibility reasons (PD). Needs to be loaded prior to
+			// ant class if we are going to implement it.
+			// System.setSecurityManager(new NoExitSecurityManager());
+			try {
+				if (easyAntConfiguration.isAllowInput()) {
+					project.setDefaultInputStream(System.in);
+				}
+				System.setIn(new DemuxInputStream(project));
+				System.setOut(new PrintStream(new DemuxOutputStream(project,
+						false)));
+				System.setErr(new PrintStream(new DemuxOutputStream(project,
+						true)));
+				EasyAntEngine.configureAndInitProject(project, easyAntConfiguration);
+				printDescription(project);
+				printTargets(project,
+						easyAntConfiguration.getMsgOutputLevel() > Project.MSG_INFO);
+			} finally {
+				// put back the original security manager
+				// The following will never eval to true. (PD)
+				if (oldsm != null) {
+					System.setSecurityManager(oldsm);
+				}
+
+				System.setOut(savedOut);
+				System.setErr(savedErr);
+				System.setIn(savedIn);
+			}
+		} catch (RuntimeException exc) {
+			error = exc;
+			throw exc;
+		} catch (Error e) {
+			error = e;
+			throw e;
+		} finally {
+			if (error != null) {
+				project.log(error.toString(), Project.MSG_ERR);
+			}
+		}
+	}
+	
+	/**
+	 * Prints the usage information for this class to <code>System.out</code>.
+	 */
+	private static void printUsage() {
+		String lSep = System.getProperty("line.separator");
+		StringBuffer msg = new StringBuffer();
+		msg.append("easyant [options] [target [target2 [target3] ...]]" + lSep);
+		msg.append("Options: " + lSep);
+		msg.append("  -help, -h              print this message" + lSep);
+		msg.append("  -projecthelp, -p       print project help information"
+				+ lSep);
+		msg
+				.append("  -version               print the version information and exit"
+						+ lSep);
+		msg
+				.append("  -diagnostics           print information that might be helpful to"
+						+ lSep);
+		msg.append("                         diagnose or report problems."
+				+ lSep);
+		msg
+				.append("  -showMemoryDetails     print memory details (used/free/total)"
+						+ lSep);
+		msg.append("  -quiet, -q             be extra quiet" + lSep);
+		msg.append("  -verbose, -v           be extra verbose" + lSep);
+		msg.append("  -debug, -d             print debugging information"
+				+ lSep);
+		msg
+				.append("  -emacs, -e             produce logging information without adornments"
+						+ lSep);
+		msg
+				.append("  -lib <path>            specifies a path to search for jars and classes"
+						+ lSep);
+		msg.append("  -logfile <file>        use given file for log" + lSep);
+		msg.append("    -l     <file>                ''" + lSep);
+		msg
+				.append("  -logger <classname>    the class which is to perform logging"
+						+ lSep);
+		msg
+				.append("  -listener <classname>  add an instance of class as a project listener"
+						+ lSep);
+		msg.append("  -noinput               do not allow interactive input"
+				+ lSep);
+		msg.append("  -buildmodule <file>    use given buildmodule" + lSep);
+		msg.append("    -file    <file>              ''" + lSep);
+		msg.append("    -f       <file>              ''" + lSep);
+		msg.append("  -listTargets           Lists all targets available"+lSep);
+		msg.append("  -listTargets <arg>     Lists all targets associated with specified phase / plugin as argument"+lSep);
+		msg.append("  -listPhases            Lists all phases available"+lSep);
+		msg.append("  -listPlugins           Lists all plugins / modules imported by specified build module"+lSep);
+		msg.append("  -listProps <plugin>    Lists all properties available in the specified imported module"+lSep);
+		msg.append("  -describe <arg>        Describes the phase / target / property specified by the argument"+lSep);
+		msg.append("  -buildconf <confs>     specify build configurations (profiles)"+lSep);
+		msg.append("    -C  <confs>                  ''"+lSep);
+		msg.append("  -buildfile <file>      use given buildfile" + lSep);
+		msg.append("  -config-file <file>    use given easyant configuration"
+				+ lSep);
+		msg.append("  -D<property>=<value>   use value for given property"
+				+ lSep);
+		msg
+				.append("  -keep-going, -k        execute all targets that do not depend"
+						+ lSep);
+		msg.append("                         on failed target(s)" + lSep);
+		msg
+				.append("  -propertyfile <name>   load all properties from file with -D"
+						+ lSep);
+		msg.append("                         properties taking precedence"
+				+ lSep);
+		msg
+				.append("  -inputhandler <class>  the class which will handle input requests"
+						+ lSep);
+		msg
+				.append("  -find <file>           (s)earch for buildfile towards the root of"
+						+ lSep);
+		msg.append("    -s  <file>           the filesystem and use it" + lSep);
+		msg
+				.append("  -nice  number          A niceness value for the main thread:"
+						+ lSep
+						+ "                         1 (lowest) to 10 (highest); 5 is the default"
+						+ lSep);
+		msg
+				.append("  -nouserlib             Run ant without using the jar files from"
+						+ lSep
+						+ "                         ${user.home}/.ant/lib"
+						+ lSep);
+		msg.append("  -noclasspath           Run ant without using CLASSPATH"
+				+ lSep);
+		msg
+				.append("  -autoproxy             Java1.5+: use the OS proxy settings"
+						+ lSep);
+		msg
+				.append("  -main <class>          override Ant's normal entry point");
+		System.out.println(msg.toString());
+	}
+
+	/**
+	 * Prints the EasyAnt version information to <code>System.out</code>.
+	 * 
+	 * @exception BuildException
+	 *                if the version information is unavailable
+	 */
+	private static void printVersion(int logLevel) throws BuildException {
+		System.out.println(EasyAntEngine.getEasyAntVersion());
+		System.out.println(getAntVersion());
+	}
+
+	/**
+	 * Cache of the Ant version information when it has been loaded.
+	 */
+	private static String antVersion = null;
+
+	/**
+	 * Returns the Ant version information, if available. Once the information
+	 * has been loaded once, it's cached and returned from the cache on future
+	 * calls.
+	 * 
+	 * @return the Ant version information as a String (always non-
+	 *         <code>null</code>)
+	 * 
+	 * @exception BuildException
+	 *                if the version information is unavailable
+	 */
+	public static synchronized String getAntVersion() throws BuildException {
+		if (antVersion == null) {
+			try {
+				Properties props = new Properties();
+				InputStream in = Main.class
+						.getResourceAsStream("/org/apache/tools/ant/version.txt");
+				props.load(in);
+				in.close();
+
+				StringBuffer msg = new StringBuffer();
+				msg.append("Apache Ant version ");
+				msg.append(props.getProperty("VERSION"));
+				msg.append(" compiled on ");
+				msg.append(props.getProperty("DATE"));
+				antVersion = msg.toString();
+			} catch (IOException ioe) {
+				throw new BuildException(
+						"Could not load the version information:"
+								+ ioe.getMessage());
+			} catch (NullPointerException npe) {
+				throw new BuildException(
+						"Could not load the version information.");
+			}
+		}
+		return antVersion;
+	}
+
+}

Propchange: incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/EasyAntMain.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/EasyAntMain.java
------------------------------------------------------------------------------
    svn:executable = *

Propchange: incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/EasyAntMain.java
------------------------------------------------------------------------------
    svn:keywords = Date Revision Author HeadURL Id

Propchange: incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/EasyAntMain.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain

Added: incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/ant/EasyAntProjectHelper.java
URL: http://svn.apache.org/viewvc/incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/ant/EasyAntProjectHelper.java?rev=1071697&view=auto
==============================================================================
--- incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/ant/EasyAntProjectHelper.java (added)
+++ incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/ant/EasyAntProjectHelper.java Thu Feb 17 17:01:07 2011
@@ -0,0 +1,302 @@
+/* 
+ *  Copyright 2008-2010 the EasyAnt project
+ * 
+ *  See the NOTICE file distributed with this work for additional information
+ *  regarding copyright ownership. 
+ * 
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ * 
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ *  Unless required by applicable law or agreed to in writing, software 
+ *  distributed under the License is distributed on an "AS IS" BASIS, 
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and 
+ *  limitations under the License.
+ */
+package org.apache.easyant.core.ant;
+
+import java.util.Hashtable;
+import java.util.Iterator;
+
+import org.apache.tools.ant.BuildException;
+import org.apache.tools.ant.ExtensionPoint;
+import org.apache.tools.ant.Location;
+import org.apache.tools.ant.Project;
+import org.apache.tools.ant.ProjectHelper;
+import org.apache.tools.ant.Target;
+import org.apache.tools.ant.helper.AntXMLContext;
+import org.apache.tools.ant.helper.ProjectHelper2;
+import org.xml.sax.Attributes;
+import org.xml.sax.SAXParseException;
+
+/**
+ * This class is the custom project helper used by easyant introducing support
+ * for phase concept
+ * 
+ */
+public class EasyAntProjectHelper extends ProjectHelper2 {
+
+	public EasyAntProjectHelper() {
+		super();
+		setProjectHandler(new EasyAntProjectHandler());
+		setTargetHandler(new EasyAntTargetHandler());
+	}
+
+	/**
+	 * Handler for the top level "project" element.
+	 */
+	public static class EasyAntProjectHandler extends ProjectHandler {
+
+		/**
+		 * Handles the start of a top-level element within the project. An
+		 * appropriate handler is created and initialised with the details of
+		 * the element.
+		 * 
+		 * @param uri
+		 *            The namespace URI for this element.
+		 * @param name
+		 *            The name of the element being started. Will not be
+		 *            <code>null</code>.
+		 * @param qname
+		 *            The qualified name for this element.
+		 * @param attrs
+		 *            Attributes of the element being started. Will not be
+		 *            <code>null</code>.
+		 * @param context
+		 *            The context for this element.
+		 * @return a target or an element handler.
+		 * 
+		 * @exception org.xml.sax.SAXParseException
+		 *                if the tag given is not <code>"taskdef"</code>,
+		 *                <code>"typedef"</code>, <code>"property"</code>,
+		 *                <code>"target"</code>, <code>"phase"</code> or a data
+		 *                type definition
+		 */
+		public AntHandler onStartChild(String uri, String name, String qname,
+				Attributes attrs, AntXMLContext context)
+				throws SAXParseException {
+
+			return (name.equals("target") || name.equals("phase") || name
+					.equals("extension-point"))
+					&& (uri.equals("") || uri.equals(ANT_CORE_URI)) ? getTargetHandler()
+					: getElementHandler();
+		}
+	}
+
+	/**
+	 * Handler for "target" and "phase" elements.
+	 */
+	public static class EasyAntTargetHandler extends TargetHandler {
+
+		/**
+		 * Initialisation routine called after handler creation with the element
+		 * name and attributes. The attributes which this handler can deal with
+		 * are: <code>"name"</code>, <code>"depends"</code>, <code>"if"</code>,
+		 * <code>"unless"</code>, <code>"id"</code> and
+		 * <code>"description"</code>.
+		 * 
+		 * @param uri
+		 *            The namespace URI for this element.
+		 * @param tag
+		 *            Name of the element which caused this handler to be
+		 *            created. Should not be <code>null</code>. Ignored in this
+		 *            implementation.
+		 * @param qname
+		 *            The qualified name for this element.
+		 * @param attrs
+		 *            Attributes of the element which caused this handler to be
+		 *            created. Must not be <code>null</code>.
+		 * @param context
+		 *            The current context.
+		 * 
+		 * @exception SAXParseException
+		 *                if an unexpected attribute is encountered or if the
+		 *                <code>"name"</code> attribute is missing.
+		 */
+		public void onStartElement(String uri, String tag, String qname,
+				Attributes attrs, AntXMLContext context)
+				throws SAXParseException {
+
+			String name = null;
+			String depends = "";
+			String extensionPoint = null;
+			String phase = null;
+
+			Project project = context.getProject();
+
+			Target target;
+			if ("extension-point".equals(tag)) {
+				target = new ExtensionPoint();
+			} else if ("phase".equals(tag)) {
+				target = new Phase();
+			} else {
+				target = new Target();
+			}
+
+			target.setProject(project);
+			target.setLocation(new Location(context.getLocator()));
+			context.addTarget(target);
+
+			for (int i = 0; i < attrs.getLength(); i++) {
+				String attrUri = attrs.getURI(i);
+				if (attrUri != null && !attrUri.equals("")
+						&& !attrUri.equals(uri)) {
+					continue; // Ignore attributes from unknown uris
+				}
+				String key = attrs.getLocalName(i);
+				String value = attrs.getValue(i);
+
+				if (key.equals("name")) {
+					name = value;
+					if ("".equals(name)) {
+						throw new BuildException("name attribute must "
+								+ "not be empty");
+					}
+				} else if (key.equals("depends")) {
+					depends = value;
+				} else if (key.equals("if")) {
+					target.setIf(value);
+				} else if (key.equals("unless")) {
+					target.setUnless(value);
+				} else if (key.equals("id")) {
+					if (value != null && !value.equals("")) {
+						context.getProject().addReference(value, target);
+					}
+				} else if (key.equals("description")) {
+					target.setDescription(value);
+				} else if (key.equals("extensionOf")) {
+					extensionPoint = value;
+				} else if (key.equals("phase")) {
+					phase = value;
+				} else {
+					throw new SAXParseException("Unexpected attribute \"" + key
+							+ "\"", context.getLocator());
+				}
+			}
+
+			if (name == null) {
+				throw new SAXParseException(
+						"target element appears without a name attribute",
+						context.getLocator());
+			}
+
+			boolean isPhase = target instanceof Phase;
+
+			String prefix = null;
+			boolean isInIncludeMode = context.isIgnoringProjectTag()
+					&& isInIncludeMode();
+			String sep = getCurrentPrefixSeparator();
+
+			if (isInIncludeMode && !isPhase) {
+				prefix = getTargetPrefix(context);
+				if (prefix == null) {
+					throw new BuildException("can't include build file "
+							+ context.getBuildFile()
+							+ ", no as attribute has been given"
+							+ " and the project tag doesn't"
+							+ " specify a name attribute");
+				}
+				name = prefix + sep + name;
+			}
+
+			// Check if this target is in the current build file
+			if (context.getCurrentTargets().get(name) != null) {
+				throw new BuildException("Duplicate target '" + name + "'",
+						target.getLocation());
+			}
+			Hashtable projectTargets = project.getTargets();
+			boolean usedTarget = false;
+			// If the name has not already been defined define it
+			if (projectTargets.containsKey(name)) {
+				project.log(
+						"Already defined in main or a previous import, ignore "
+								+ name, Project.MSG_VERBOSE);
+			} else {
+				target.setName(name);
+				context.getCurrentTargets().put(name, target);
+				project.addOrReplaceTarget(name, target);
+				usedTarget = true;
+			}
+
+			if (depends.length() > 0) {
+				if (!isInIncludeMode) {
+					target.setDepends(depends);
+				} else {
+					for (Iterator iter = Target.parseDepends(depends, name,
+							"depends").iterator(); iter.hasNext();) {
+						String curTarget = (String) iter.next();
+						if (projectTargets.containsKey(curTarget) && (projectTargets.get(curTarget) instanceof Phase)) {
+							
+							target.addDependency(curTarget);
+						} else {
+							target.addDependency(prefix + sep + curTarget);
+						}
+					}
+				}
+			}
+			if (!isInIncludeMode && context.isIgnoringProjectTag()
+					&& (prefix = getTargetPrefix(context)) != null) {
+				// In an imported file (and not completely
+				// ignoring the project tag or having a preconfigured prefix)
+				String newName = prefix + sep + name;
+				Target newTarget = usedTarget ? new Target(target) : target;
+				newTarget.setName(newName);
+				context.getCurrentTargets().put(newName, newTarget);
+				project.addOrReplaceTarget(newName, newTarget);
+			}
+			if (extensionPoint != null) {
+				ProjectHelper helper = (ProjectHelper) context.getProject()
+						.getReference(ProjectHelper.PROJECTHELPER_REFERENCE);
+				for (Iterator iter = Target.parseDepends(extensionPoint, name,
+						"extensionOf").iterator(); iter.hasNext();) {
+					String tgName = (String) iter.next();
+					if (isInIncludeMode()) {
+						tgName = prefix + sep + tgName;
+					}
+
+					// defer extensionpoint resolution until the full
+					// import stack has been processed
+					helper.getExtensionStack().add(
+							new String[] { tgName, name });
+				}
+			}
+			if (phase != null) {
+				if (!projectTargets.containsKey(phase)) {
+					throw new BuildException("can't add target " + name
+							+ " to phase " + phase + " because the phase"
+							+ " is unknown.");
+				}
+				Target t = (Target) projectTargets.get(phase);
+
+				if (!(t instanceof Phase)) {
+					throw new BuildException("referenced target " + phase
+							+ " is not a phase");
+				}
+				t.addDependency(name);
+			}
+
+		}
+
+		private String getTargetPrefix(AntXMLContext context) {
+			String configuredValue = getCurrentTargetPrefix();
+			if (configuredValue != null && configuredValue.length() == 0) {
+				configuredValue = null;
+			}
+			if (configuredValue != null) {
+				return configuredValue;
+			}
+
+			String projectName = context.getCurrentProjectName();
+			if ("".equals(projectName)) {
+				projectName = null;
+			}
+
+			return projectName;
+		}
+
+	}
+
+}

Propchange: incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/ant/EasyAntProjectHelper.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/ant/EasyAntProjectHelper.java
------------------------------------------------------------------------------
    svn:keywords = Date Revision Author HeadURL Id

Propchange: incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/ant/EasyAntProjectHelper.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain

Added: incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/ant/MetaBuildExecutor.java
URL: http://svn.apache.org/viewvc/incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/ant/MetaBuildExecutor.java?rev=1071697&view=auto
==============================================================================
--- incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/ant/MetaBuildExecutor.java (added)
+++ incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/ant/MetaBuildExecutor.java Thu Feb 17 17:01:07 2011
@@ -0,0 +1,169 @@
+/* 
+ *  Copyright 2008-2010 the EasyAnt project
+ * 
+ *  See the NOTICE file distributed with this work for additional information
+ *  regarding copyright ownership. 
+ * 
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ * 
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ *  Unless required by applicable law or agreed to in writing, software 
+ *  distributed under the License is distributed on an "AS IS" BASIS, 
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and 
+ *  limitations under the License.
+ */
+package org.apache.easyant.core.ant;
+
+import java.io.File;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.apache.easyant.core.EasyAntConstants;
+import org.apache.easyant.core.EasyAntMagicNames;
+import org.apache.easyant.core.ivy.IvyInstanceHelper;
+import org.apache.easyant.tasks.SubModule;
+import org.apache.easyant.tasks.SubModule.TargetList;
+import org.apache.ivy.ant.IvyAntSettings;
+import org.apache.ivy.ant.IvyBuildList;
+import org.apache.ivy.core.module.descriptor.Artifact;
+import org.apache.ivy.core.module.descriptor.MDArtifact;
+import org.apache.ivy.core.module.descriptor.ModuleDescriptor;
+import org.apache.ivy.core.settings.IvySettings;
+import org.apache.ivy.plugins.parser.ModuleDescriptorParser;
+import org.apache.ivy.plugins.parser.ModuleDescriptorParserRegistry;
+import org.apache.ivy.plugins.repository.url.URLResource;
+import org.apache.tools.ant.BuildException;
+import org.apache.tools.ant.Project;
+import org.apache.tools.ant.helper.DefaultExecutor;
+import org.apache.tools.ant.types.FileSet;
+import org.apache.tools.ant.types.Reference;
+import org.apache.tools.ant.types.selectors.FilenameSelector;
+
+/**
+ * Recursively executes build targets on sub-modules for a multi-module project.
+ */
+public class MetaBuildExecutor extends DefaultExecutor {
+
+	@Override
+	public void executeTargets(Project project, String[] targets)
+			throws BuildException {
+
+		// delegate to the ivy:buildlist task to compute an ordered list of
+		// submodules
+		FilenameSelector ivySelector = new FilenameSelector();
+		ivySelector.setProject(project);
+		ivySelector.setName("**/module.ivy");
+
+		FileSet ivyFiles = (FileSet) project.createDataType("fileset");
+		ivyFiles.setDir(project.getBaseDir());
+		ivyFiles.setExcludes("module.ivy"); // exclude the root module ivy.
+		ivyFiles.setIncludes(project.getProperty("submodule.dirs"));
+		ivyFiles.addFilename(ivySelector);
+
+		IvyBuildList buildList = new IvyBuildList();
+		buildList.setTaskName("meta:buildlist");
+		buildList.setProject(project);
+		buildList.setReference("build-path");
+		buildList.setIvyfilepath("module.ivy");
+		buildList.setSettingsRef(IvyInstanceHelper
+				.buildProjectIvyReference(project));
+		buildList.addFileset(ivyFiles);
+
+		buildList.execute();
+
+		// publish the parent module descriptor into the build-scoped
+		// repository, so that it can
+		// be used by submodules if needed
+		File moduleFile = new File(project.getBaseDir(), "module.ivy");
+		String buildRepo = project
+				.getProperty(EasyAntMagicNames.EASYANT_BUILD_REPOSITORY);
+		if (moduleFile.isFile() && buildRepo != null) {
+
+			project.log("Publishing module descriptor " + moduleFile.getPath()
+					+ " to build repository '" + buildRepo + "'");
+
+			IvyAntSettings projectSettings = IvyInstanceHelper
+					.getProjectIvyAntSettings(project);
+			IvySettings ivy = projectSettings.getConfiguredIvyInstance(
+					buildList).getSettings();
+
+			try {
+				URL ivyUrl = moduleFile.toURL();
+				ModuleDescriptorParser mdp = ModuleDescriptorParserRegistry
+						.getInstance().getParser(
+								new URLResource(moduleFile.toURL()));
+				ModuleDescriptor descriptor = mdp.parseDescriptor(ivy, ivyUrl,
+						true);
+				Artifact artifact = MDArtifact.newIvyArtifact(descriptor);
+				ivy.getResolver(buildRepo).publish(artifact, moduleFile, true);
+			} catch (Exception ioe) {
+				throw new BuildException("Error publishing meta-module file "
+						+ moduleFile.getAbsolutePath() + " to " + buildRepo,
+						ioe);
+			}
+
+		}
+
+		// hook for pre-module-targets
+		String preModuleTargets = project
+				.getProperty(EasyAntMagicNames.PRE_MODULE_TARGETS);
+		if (preModuleTargets == null) {
+			preModuleTargets = EasyAntConstants.DEFAULT_PRE_MODULE_TARGETS;
+		}
+
+		List<String> postTargetsToRun = new ArrayList<String>();
+		List<String> preTargetsToRun = new ArrayList<String>();
+		List<String> preModuleTargetList = Arrays.asList(preModuleTargets
+				.split(","));
+		for (int i = 0; i < targets.length; i++) {
+			if (preModuleTargetList.contains(targets[i])) {
+				// fill a list of targets to run BEFORE subproject delegation
+				preTargetsToRun.add(targets[i]);
+			} else {
+				// fill a list of target to run AFTER subproject delagation
+				// make sure target exists
+				if (project.getTargets().get(targets[i]) != null) {
+					postTargetsToRun.add(targets[i]);
+				} else {
+					project.log("Skipping undefined target '" + targets[i] + "'",
+							Project.MSG_VERBOSE);
+				}
+
+			}
+		}
+
+		// now call the default executor to include any extra
+		// targets defined in the root module.ant
+		super.executeTargets(project, preTargetsToRun.toArray(new String[] {}));
+
+		// delegate to the ea:submodule task to execute the list of targets on
+		// all modules in the build list
+		SubModule subModule = new SubModule();
+		subModule.setTaskName("meta:submodule");
+		subModule.setProject(project);
+
+		Boolean useBuildRepository = project
+				.getProperty(EasyAntMagicNames.USE_BUILD_REPOSITORY) != null ? Boolean
+				.parseBoolean(project
+						.getProperty(EasyAntMagicNames.USE_BUILD_REPOSITORY))
+				: true;
+		subModule.setUseBuildRepository(useBuildRepository);
+
+		subModule.setBuildpathRef(new Reference(project, "build-path"));
+		subModule.setTargets(new TargetList(targets));
+		subModule.execute();
+
+		// now call the default executor to include any extra targets defined in
+		// the root module.ant
+		super
+				.executeTargets(project, postTargetsToRun
+						.toArray(new String[] {}));
+	}
+
+}

Propchange: incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/ant/MetaBuildExecutor.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/ant/MetaBuildExecutor.java
------------------------------------------------------------------------------
    svn:keywords = Date Revision Author HeadURL Id

Propchange: incubator/easyant/core/trunk/src/main/java/org/apache/easyant/core/ant/MetaBuildExecutor.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain



Mime
View raw message