[ http://issues.apache.org/jira/browse/JELLY-225?page=all ]
Ryan Heaton updated JELLY-225:
------------------------------
Attachment: testBasicExample.jelly
testForAllTypesIncludeInterfaces.jelly
I've attached some basic examples:
testBasicExample.jelly: An example script that runs through all source files
and outputs as properties each type's various members, annotations, docs, etc.
testForAllTypesIncludeInterfaces.jelly: An example script that iterates through
all types, including interfaces, that have a certain annotation
> apt jelly tag library
> ---------------------
>
> Key: JELLY-225
> URL: http://issues.apache.org/jira/browse/JELLY-225
> Project: jelly
> Type: New Feature
> Components: submissions
> Reporter: Ryan Heaton
> Attachments: testBasicExample.jelly, testForAllTypesIncludeInterfaces.jelly
>
> This is a proposal for a new jelly tag library that provides an interface to
> the new Java 5 Annotation Processing Tool (apt) and its associated Mirror API
> (see http://java.sun.com/j2se/1.5.0/docs/guide/apt/index.html).
> From the official apt documentation: "apt is a command-line utility for
> annotation processing. It includes a set of reflective APIs and supporting
> infrastructure to process program annotations (JSR 175). These reflective
> APIs provide a build-time, source-based, read-only view of program structure.
> They are designed to cleanly model the Java programming language's type
> system after the addition of generics (JSR 14)."
> Developers who which to process Java source code are presently limited to
> working with the Mirror API directly. If, for example, a developer wished to
> generate an artifact such as an xml config file or another Java class must do
> so by writing to an instance of java.io.PrintWriter.
> As an admittedly impotent example, to generate a simple class that will print
> out all methods of all classes in a given source base, the developer would
> implement instances of com.sun.mirror.apt.AnnotationProcessorFactory and
> com.sun.mirror.apt.AnnotationProcessor that look something like this:
> package org.apache.commons.jelly.examples;
> import java.util.Collection;
> import java.util.Set;
> import java.util.Collections;
> import java.io.IOException;
> import java.io.PrintWriter;
> import com.sun.mirror.apt.AnnotationProcessorFactory;
> import com.sun.mirror.apt.AnnotationProcessor;
> import com.sun.mirror.apt.AnnotationProcessorEnvironment;
> import com.sun.mirror.declaration.AnnotationTypeDeclaration;
> import com.sun.mirror.declaration.TypeDeclaration;
> import com.sun.mirror.declaration.MethodDeclaration;
> public class ClassAndMethodPrinterAnnotationProcessorFactory implements
> AnnotationProcessorFactory {
> public Collection<String> supportedOptions() {
> return Collections.EMPTY_LIST;
> }
> public Collection<String> supportedAnnotationTypes() {
> return Collections.EMPTY_LIST;
> }
> public AnnotationProcessor
> getProcessorFor(Set<AnnotationTypeDeclaration> atds,
> AnnotationProcessorEnvironment env) {
> return new ClassAndMethodPrinterAnnotationProcessor(env);
> }
> private class ClassAndMethodPrinterAnnotationProcessor implements
> AnnotationProcessor {
> AnnotationProcessorEnvironment env;
> public
> ClassAndMethodPrinterAnnotationProcessor(AnnotationProcessorEnvironment env) {
> this.env = env;
> }
> public void process() {
> try {
> PrintWriter writer =
> env.getFiler().createSourceFile("org.apache.commons.jelly.examples.ClassAndMethodPrinter");
> writer.println("package org.apache.commons.jelly.examples;");
> writer.println();
> writer.println("public class ClassAndMethodPrinter {");
> writer.println();
> writer.println(" public static void main(String[] args) {");
> for (TypeDeclaration typeDeclaration : env.getTypeDeclarations())
> {
> writer.println(String.format(" System.out.println(\"Class:
> %s\");", typeDeclaration.getQualifiedName()));
> for (MethodDeclaration methodDeclaration :
> typeDeclaration.getMethods()) {
> writer.println(String.format("
> System.out.println(\"Method: %s.%s\");", typeDeclaration.getQualifiedName(),
> methodDeclaration.getSimpleName()));
> }
> }
> writer.println(" }");
> writer.println();
> writer.println("}");
> }
> catch (IOException e) {
> throw new RuntimeException(e);
> }
> }
> }
> }
> Any Java programmer with a little bit of experience could testify that using
> a PrintWriter for large and complex output is significantly heavy and
> burdensome. To use a familiar paradigm in J2EE, nobody wants to use a
> Servlet's PrintWriter for outputting many large and complex html documents.
> For this reason, Java Server Pages (JSP) were created to ease development of
> complex output.
> An apt tag library would be to the Mirror API what JSPs are to the Servlet
> API. Instead of writing implementations of AnnotationProcessorFactory and
> AnnotationProcessor, why not just use Jelly to manage your output, like so:
> <j:jelly xmlns:j="jelly:core" xmlns:apt="jelly:apt">
> <apt:javaSource
> name="org.apache.commons.jelly.examples.ClassAndMethodPrinter">
> package org.apache.commons.jelly.examples;
> public class ClassAndMethodPrinter {
> public static void main(String[] args) {
> <apt:forAllTypes var="type">
> System.out.println("<j:out value="${type.qualifiedName}"/>");
> <apt:forAllMethods var="method">
> System.out.println("<j:out value="${type.qualifiedName}"/>.<j:out
> value="${method.simpleName}"/>");
> </apt:forAllMethods>
> </apt:forAllTypes>
> }
> }
> </apt:javaSource>
> </j:jelly>
>
> Not only is the requirement to implement Mirror API classes lifted from the
> developer, but it's easy to see how easily Jelly provides a much cleaner and
> easier-to-read abstraction on top of the Mirror API. Developers could also
> take advantage of the rich set of jelly tag libararies for managing output.
> The new apt tag library would be a replacement for the popular tool XDoclet
> (see http://xdoclet.sourceforge.net). Not only would it provide everything
> that XDoclet currently provides, but it would have many significant
> advantages over XDoclet, including:
> -No tight coupling to Ant
> -Availability of a rich set of tag libraries, including all the current jelly
> tag libararies like jelly core and xml taglibs.
> -Complete support for full Java 5 syntax, including generics, annotations,
> static imports, enums, etc.
> -A richer (and significantly cleaner) template language (i.e. Jelly)
> -A more complete set of tags for traversing source code classes, including
> tags like forAllPackages, forAllImportedTypes, forAllNestedTypes,
> forAllThrownTypes, etc.
> I already have everything implemented and integrated into the current maven
> jelly build. Attached are a few examples that show what this new library can
> do. All examples output properties files (these are examples I use for unit
> testing).
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://issues.apache.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see:
http://www.atlassian.com/software/jira
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
