KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > antmod > tasks > ModuleIteratorTask


1 package org.antmod.tasks;
2
3 import java.io.File JavaDoc;
4 import java.util.ArrayList JavaDoc;
5 import java.util.Iterator JavaDoc;
6
7 import org.antmod.conf.AntmodProperties;
8 import org.antmod.descriptor.DescriptorStoreFactory;
9 import org.antmod.descriptor.ReleaseDescriptor;
10 import org.antmod.descriptor.ReleaseTask;
11 import org.antmod.descriptor.ReleaseDescriptor.Module;
12 import org.apache.commons.lang.StringUtils;
13 import org.apache.tools.ant.BuildException;
14 import org.apache.tools.ant.Project;
15 import org.apache.tools.ant.Task;
16 import org.apache.tools.ant.taskdefs.Ant;
17 import org.apache.tools.ant.taskdefs.CallTarget;
18 import org.apache.tools.ant.taskdefs.Property;
19 import org.apache.tools.ant.taskdefs.Ant.Reference;
20
21 /**
22  * Allow buildfiles to execute some things per module, by invoking a target in
23  * the buildfile per module in the given release. This task sets the variables
24  * 'antmod.moduleiterator.module.name', 'antmod.moduleiterator.module.version' etc.
25  * which the target that is invoked can use.
26  *
27  * @author Klaas Waslander
28  */
29 public final class ModuleIteratorTask extends Task {
30
31     private ReleaseDescriptor descriptor;
32
33     private String JavaDoc target;
34
35     private boolean antOnModule;
36
37     private String JavaDoc[] includeTypes;
38
39     private String JavaDoc[] excludeTypes;
40     
41     private boolean logNewlines;
42     
43     private ArrayList JavaDoc passbackRefs = new ArrayList JavaDoc();
44
45     /**
46      * Public default constructor.
47      */
48     public ModuleIteratorTask() {
49     }
50
51     /**
52      * Executes the given target for the selected module types in the given release,
53      * if no release descriptor was specified the one defined in the
54      * Ant property "antmod.release" is used.
55      */
56     public void execute() throws BuildException {
57         // check for valid ant task arguments
58 if (this.descriptor == null) {
59             throw new BuildException("FAIL: 'descriptor' attribute of moduleiterator task has to be set.");
60         }
61
62         // start iterating across the modules
63 Iterator JavaDoc moduleIter = descriptor.getModules().iterator();
64         while (moduleIter.hasNext()) {
65             Module module = (Module) moduleIter.next();
66             if (includesModuleType(module.getType())) {
67                 invokeTargetForModule(module);
68             }
69             if (this.logNewlines) {
70                 getProject().log("", Project.MSG_WARN);
71             }
72         }
73     }
74
75     /**
76      * Invokes the Ant target for the given module.
77      *
78      * @param module
79      * The module for which the Ant target needs to be invoked.
80      */
81     private void invokeTargetForModule(Module module) throws BuildException {
82         Task invokeTask = null;
83         if (antOnModule) {
84             ConditionalAnt antTask = new ConditionalAnt();
85             antTask.setInheritAll(true);
86             antTask.setInheritRefs(true);
87             antTask.setProject(getProject());
88             antTask.setTaskName(getTaskName());
89             antTask.setTarget(this.target);
90             antTask.setDir(new File JavaDoc(ReleaseTask.getReleaseDir(getProject()), module.getName()));
91             antTask.setAntfile(AntmodProperties.getProperty("antmod.module.antfile"));
92             antTask.setPassbackRefs(this.passbackRefs);
93             invokeTask = antTask;
94         }
95         else {
96             CallTarget antcall = new CallTarget();
97             antcall.setInheritAll(true);
98             antcall.setProject(getProject());
99             antcall.setTaskName(getTaskName());
100             antcall.setTarget(this.target);
101             invokeTask = antcall;
102         }
103
104         createInvokeParam(invokeTask, "antmod.release.name", this.descriptor.getName());
105         createInvokeParam(invokeTask, "antmod.release.version", this.descriptor.getVersionString());
106
107         createInvokeParam(invokeTask, "antmod.ismainmodule", String.valueOf(module.equals(this.descriptor.getMainModule())));
108         createInvokeParam(invokeTask, "antmod.isbuildreleasemodule", String.valueOf(module.equals(this.descriptor.getBuildReleaseModule())));
109
110         createInvokeParam(invokeTask, "antmod.moduleiterator.module.name", module.getName());
111         createInvokeParam(invokeTask, "antmod.moduleiterator.module.version", module.getVersion());
112         createInvokeParam(invokeTask, "antmod.moduleiterator.module.type", module.getType());
113         if (module.getRepos() != null) {
114             createInvokeParam(invokeTask, "antmod.moduleiterator.module.repos", module.getRepos());
115         }
116         if (this.descriptor.getScmRevision() != null) {
117             createInvokeParam(invokeTask, "antmod.release.scm.revision", this.descriptor.getScmRevision());
118         }
119
120         invokeTask.execute();
121     }
122
123     static void createInvokeParam(Task invokeTask, String JavaDoc paramName, String JavaDoc paramValue) {
124         Property param = null;
125         if (invokeTask instanceof Ant) {
126             param = ((Ant) invokeTask).createProperty();
127         }
128         else if (invokeTask instanceof CallTarget) {
129             param = ((CallTarget) invokeTask).createParam();
130         }
131         param.setName(paramName);
132         param.setValue(paramValue);
133     }
134
135     /**
136      * Set the name of the release descriptor to be used,
137      * if not specified the release descriptor defined in the
138      * Ant property "antmod.release" is used.
139      *
140      * @param descriptorName
141      * The name of the release descriptor containing the modules for
142      * iterating across.
143      */
144     public void setDescriptor(String JavaDoc descriptorName) {
145         if (descriptorName == null) {
146             descriptorName = getProject().getProperty("antmod.release");
147         }
148         if (descriptorName != null) {
149             this.descriptor = DescriptorStoreFactory.getConfiguredDescriptorStore().getReleaseDescriptor(descriptorName);
150         }
151     }
152
153     /**
154      * The Ant target to-be-invoked for each module in the release descriptor.
155      */
156     public void setTarget(String JavaDoc target) {
157         this.target = target;
158     }
159
160     /**
161      * If set to true, ant will be invoked on the module's Ant file.
162      */
163     public void setAntOnModule(boolean antOnModule) {
164         this.antOnModule = antOnModule;
165     }
166
167     /**
168      * Sets te module types to be iterated across; when unset, all module types
169      * are included in the iteration.
170      *
171      * @param moduleTypes
172      * Comma-separated list of module types.
173      */
174     public void setIncludeTypes(String JavaDoc includeTypes) {
175         this.includeTypes = StringUtils.split(includeTypes, ",");
176     }
177
178     /**
179      * Sets te module types that should be excludes while iterating the modules.
180      *
181      * @param moduleTypes
182      * Comma-separated list of module types.
183      */
184     public void setExcludeTypes(String JavaDoc excludeTypes) {
185         this.excludeTypes = StringUtils.split(excludeTypes, ",");
186     }
187     
188     /**
189      * If "logNewlines" is set to true, this task will log an
190      * empty line after each module's target execution; this
191      * can make console output of your build look nicer.
192      */
193     public void setLogNewlines(boolean logNewlines) {
194         this.logNewlines = logNewlines;
195     }
196
197     /**
198      * The references to be passed back from the module invocations,
199      * see ConditionalAnt class for more information.
200      *
201      * @param passbackReference Nested reference to be passed-back from module(s) to this project
202      */
203     public void addPassbackRef(Reference passbackReference) {
204         this.passbackRefs.add(passbackReference);
205     }
206
207     /**
208      * Checks whether the given moduleType is included in the iteration.
209      */
210     private boolean includesModuleType(String JavaDoc moduleType) {
211         if (this.excludeTypes != null) {
212             for (int i = this.excludeTypes.length; i-- > 0;) {
213                 if (this.excludeTypes[i].equalsIgnoreCase(moduleType)) {
214                     return false;
215                 }
216             }
217         }
218         if (this.includeTypes != null) {
219             boolean releaseHasBuildreleaseModule = !this.descriptor.getModulesByType(Module.TYPE_BUILDRELEASE).isEmpty();
220             for (int i = this.includeTypes.length; i-- > 0;) {
221                 String JavaDoc includeType = this.includeTypes[i];
222                 if (!releaseHasBuildreleaseModule && includeType.equalsIgnoreCase(Module.TYPE_BUILDRELEASE)
223                         && Module.TYPE_MAIN.equalsIgnoreCase(moduleType)) {
224                     // handle buildrelease moduletype, in case the release has
225 // only a main module
226 return true;
227                 }
228                 else if (this.includeTypes[i].equalsIgnoreCase(moduleType)) {
229                     return true;
230                 }
231             }
232             return false;
233         }
234         return true;
235     }
236 }
Popular Tags