Adding the Listener class, made a modification to loading the debug commands. Also adding a easyant module.ivy to build the project. git-svn-id: https://svn.apache.org/repos/asf/incubator/easyant/tasks/trunk@1135974 13f79535-47bb-0310-9956-ffa450edef68
diff --git a/command-line-debugger/module.ivy b/command-line-debugger/module.ivy new file mode 100644 index 0000000..493f21b --- /dev/null +++ b/command-line-debugger/module.ivy
@@ -0,0 +1,36 @@ +<!-- + Licensed to the Apache Software Foundation (ASF) under one or more + contributor license agreements. See the NOTICE file distributed with + this work for additional information regarding copyright ownership. + The ASF licenses this file to You 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. +--> +<ivy-module version="2.0" xmlns:ea="http://www.easyant.org"> + <info organisation="org.apache.easyant.tasks" module="cl-debugger" + status="integration" revision="0.1"> + <ea:build module="build-std-java" revision="0.2"> + <ea:property name="project.ivy.instance" value="easyant.ivy.instance"/> + <ea:property name="src.main.java" value="src/main"/> + <ea:property name="src.main.resources" value="src/main"/> + <ea:property name="resources.std.includes.pattern" value="**/*.properties"/> + </ea:build> + </info> + <configurations> + <conf name="default" visibility="public" description="runtime dependencies artifact can be used with this conf"/> + <conf name="test" visibility="private" description="this scope indicates that the dependency is not required for normal use of the application, and is only available for the test compilation and execution phases."/> + <conf name="provided" visibility="public" description="this is much like compile, but indicates you expect the JDK or a container to provide it. It is only available on the compilation classpath, and is not transitive."/> + </configurations> + <dependencies> + <dependency org="junit" name="junit" rev="4.4" conf="test->default"/> + <dependency org="org.apache.ant" name="ant" rev="1.8.2" conf="provided->default"/> + </dependencies> +</ivy-module>
diff --git a/command-line-debugger/src/main/org/apache/ant/debugger/DebugCommandSet.java b/command-line-debugger/src/main/org/apache/ant/debugger/DebugCommandSet.java index e9f60b0..aa648be 100644 --- a/command-line-debugger/src/main/org/apache/ant/debugger/DebugCommandSet.java +++ b/command-line-debugger/src/main/org/apache/ant/debugger/DebugCommandSet.java
@@ -31,7 +31,7 @@ commandSupport.putAll(commands); Properties props = new Properties(); try { - InputStream is = DebugCommandSet.class.getClassLoader() + InputStream is = Thread.currentThread().getContextClassLoader() .getResourceAsStream( "org/apache/ant/debugger/debug-support.properties"); props.load(is);
diff --git a/command-line-debugger/src/main/org/apache/tools/ant/listener/DebuggerListener.java b/command-line-debugger/src/main/org/apache/tools/ant/listener/DebuggerListener.java new file mode 100644 index 0000000..4d92a82 --- /dev/null +++ b/command-line-debugger/src/main/org/apache/tools/ant/listener/DebuggerListener.java
@@ -0,0 +1,205 @@ +package org.apache.tools.ant.listener; + +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; + +import org.apache.ant.debugger.Auditor; +import org.apache.ant.debugger.DebugCommandSet; +import org.apache.ant.debugger.DebugPrompt; +import org.apache.ant.debugger.DebugSupport; +import org.apache.ant.debugger.DefaultAuditor; +import org.apache.tools.ant.BuildEvent; +import org.apache.tools.ant.BuildListener; +import org.apache.tools.ant.MagicNames; +import org.apache.tools.ant.Project; +import org.apache.tools.ant.PropertyDebugHelper; +import org.apache.tools.ant.PropertyHelper; +import org.apache.tools.ant.Target; +import org.apache.tools.ant.input.InputHandler; + +// The input-listener should itself be pluggable +/* + * We can probably build up a stack of targets in execution to allow dumping a stack of a target + * when a break point occurs? + * + * This class also doubles as a DebugSupport Command that can be used to add new targets / properties + * to debug at runtime. + */ +public class DebuggerListener implements BuildListener, DebugSupport { + + /** + * The project being debugged. + */ + protected Project project = null; + + /** + * List of all targets at which break points have been applied. + */ + protected List debugtargets = new LinkedList(); + + /** + * Indicates if this listener instance has been initialized. + */ + protected boolean inited = false; + + /** + * Debugger instance. + */ + protected DebugPrompt prompt = null; + + /** + * Contains the current target being executed. + */ + protected Target currentTarget = null; + + /** + * An Auditor instance that keeps track of all changes to properties + * identified by the user. + */ + protected Auditor auditor = null; + + /** + * InputHandler instance that may be different than the configured one. + */ + protected InputHandler inputHandler; + + /** + * {@link DebugCommandSet} instance that is a container for all + * {@link DebugSupport} commands that may be used with this listener. + */ + protected DebugCommandSet commandHandler = new DebugCommandSet(); + + // List of all break point facilities to be available + // ================================================== + /** + * Target break point property name + */ + public static final String DEBUG_TARGET_PROPERTY = "ant.debug.target"; + + /** + * Exception break point property name + */ + public static final String DEBUG_EXCEPTION_PROPERTY = "ant.debug.exception"; + + /** + * Break point when the value of a property changes or is attempted to be + * changed. + */ + public static final String DEBUG_PROPERTY_CHANGE_PROPERTY = "ant.debug.property"; + + /** + * Request to audit all attempted changes to a property + */ + public static final String AUDIT_PROPERTY_PROPERTY = "ant.audit.property"; + + // End of all available break points + // ================================= + + public void init(BuildEvent event) { + project = event.getProject(); + project.log("Attaching DebuggerListener to the build."); + + } + + public void buildFinished(BuildEvent event) { + // Anything to do? + } + + protected Map getDefaultCommandSupport() { + if (auditor instanceof DebugSupport) { + Map defaults = new HashMap(); + defaults.put("trace", auditor); + defaults.put("add", this); + return defaults; + } + return null; + } + + public void buildStarted(BuildEvent event) { + // set audit property helper that will help keep track of properties + // being set everywhere. + project = event.getProject(); + PropertyHelper helper = new PropertyDebugHelper(); + helper.setProject(project); + auditor = new DefaultAuditor(); + ((PropertyDebugHelper) helper).setAuditor(auditor); + // Is it better to set it as a project helper or as a delegate to the + // helper? + project.addReference(MagicNames.REFID_PROPERTY_HELPER, helper); + commandHandler.setProject(project); + commandHandler.init(getDefaultCommandSupport()); + prompt = new DebugPrompt(project, commandHandler); + auditor.setPrompt(prompt); + + // this is how the debugging starts + prompt.prompt("Type /? to get any help."); + } + + public void messageLogged(BuildEvent event) { + // Do Nothing + } + + public void targetFinished(BuildEvent event) { + currentTarget = null; + } + + public void targetStarted(BuildEvent event) { + currentTarget = event.getTarget(); + Target target = event.getTarget(); + if (debugtargets.contains(target.getName())) { + prompt.prompt("Break Point at Target: " + target.getName()); + } + } + + public void taskFinished(BuildEvent event) { + } + + public void taskStarted(BuildEvent event) { + } + + /* + * The following section of code customizes this class to double up as a + * DebugSupport command instance so that it is possible to add + * target/property break points at runtime. + */ + + /** + * The current listener as a {@link DebugSupport} command only supports add + * new breakpoints. + */ + public boolean commandSupported(String command) { + return "add".equals(command); + } + + public void execute(Project project, String[] params) { + if (params.length < 3) { + printUsage(project); + return; + } + + if (!"property".equals(params[1]) && !"target".equals(params[1])) { + printUsage(project); + return; + } + + boolean isproperty = "property".equals(params[1]); + for (int i = 2; i < params.length; i++) { + if (isproperty) { + // add as a property to be audited + auditor.addPropertyForAudits(params[i], project); + project.log("Added BreakPoint at Property: " + params[2]); + } else { + debugtargets.add(params[i]); + project.log("Added BreakPoint at Target: " + params[2]); + } + } + } + + public void printUsage(Project project) { + project + .log("Some Helpful Message to add debug/property break points at runtime."); + } + +}