[CJ-dev] commonjava-projects/commonjava-opl/projects/opl-xdoclet/src/java/org/commonjava/opl/xdoclet OplNodeParserPlugin.java,NONE,1.1 OplNodeParserPlugin.vm,NONE,1.1 OplXsdPlugin.jelly,NONE,1.1 OplParserLibraryPlugin.jelly,NONE,1.1 OplXsdPlugin.java,NONE,1.1 OplParserLibraryPlugin.java,NONE,1.1

[<joh...@co...>]

Update of /cvsroot/commonjava/commonjava-projects/commonjava-opl/projects/opl-xdoclet/src/java/org/commonjava/opl/xdoclet
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv28444/projects/opl-xdoclet/src/java/org/commonjava/opl/xdoclet

Added Files:
	OplNodeParserPlugin.java OplNodeParserPlugin.vm 
	OplXsdPlugin.jelly OplParserLibraryPlugin.jelly 
	OplXsdPlugin.java OplParserLibraryPlugin.java 
Log Message:
added xdoclet2 tag library to allow XSD, OPL, and NodeParser generation from simple POJO's.

--- NEW FILE: OplNodeParserPlugin.java ---
/* Created on Mar 7, 2004 */
package org.commonjava.opl.xdoclet;

import org.commonjava.opl.xdoclet.qtags.OplImplementsTag;
import org.commonjava.util.Strings;
import org.generama.MetadataProvider;
import org.generama.VelocityPlugin;
import org.generama.WriterMapper;
import org.generama.defaults.JavaGeneratingPlugin;
import org.generama.velocity.VelocityComponent;

import com.thoughtworks.qdox.model.DocletTag;
import com.thoughtworks.qdox.model.JavaClass;
import com.thoughtworks.qdox.model.JavaMethod;

/**
 * @author jdcasey
 */
public class OplNodeParserPlugin extends JavaGeneratingPlugin {

  /**
   * @param metadataProvider
   * @param writerMapper
   * @param velocityComponent
   */
  public OplNodeParserPlugin(MetadataProvider metadataProvider,
                             WriterMapper writerMapper,
                             VelocityComponent velocityComponent)
  {
    super(metadataProvider, writerMapper, velocityComponent);
    setFileregex("\\.java");
    setFilereplace("Parser.java");
    setMultioutput(true);
  }
  
  public boolean shouldGenerate(Object metadata) {
    JavaClass jc = (JavaClass)metadata;
    return jc.getTagByName("opl.parser") != null;
  }

  public String getAttributeConstant(Object metadata){
    JavaMethod jm = (JavaMethod)metadata;
    String name = jm.getNamedParameter("opl.attribute", "name");
    return Strings.toConstantCase(name);
  }
  
  public String buildImplementsClause(Object metadata){
    JavaClass jc = (JavaClass)metadata;
    DocletTag[] tags = jc.getTagsByName("opl.implements");
    StringBuffer buffer = new StringBuffer();
    
    for (int i = 0; i < tags.length; i++) {
      buffer.append(tags[i].getNamedParameter("class")).append(", ");
    }
    
    if("true".equals(jc.getNamedParameter("opl.parser", "root"))){
      buffer.append("OPLModelRoot, ");
    }
    
    if(buffer.length() > 0){
      buffer.setLength(buffer.length() -2);
      return "implements " + buffer.toString();
    }
    else{
      return "";
    }
  }
  
}

--- NEW FILE: OplNodeParserPlugin.vm ---
#set( $class = $metadata )
package ${class.package};

import org.commonjava.opl.NodeParser;
import org.commonjava.opl.OPLContext;
import org.commonjava.opl.ParseException;
import org.commonjava.opl.ElementInfo;
#if($class.getNamedParameter("opl.parser", "root"))
import org.commonjava.opl.OPLModelRoot;
#end

#foreach($import in $class.getTagsByName("opl.aux-import"))
import $import.getNamedParameter("import");
#end

public class ${plugin.getDestinationClassname($class)} extends NodeParser 
    ${plugin.buildImplementsClause($class)} 
{
#foreach($method in $class.methods)
  #if($method.getNamedParameter("opl.attribute", "name"))
  private static final String ${plugin.getAttributeConstant($method)} = "${method.getNamedParameter("opl.attribute", "name")}";
  #end
#end

  private ${class.fullyQualifiedName} instance = new ${class.fullyQualifiedName}();

  public ${plugin.getDestinationClassname($class)}(OPLContext ctx, NodeParser parent){
    super(ctx, parent);
    #foreach($method in $class.methods)
      #if($method.getNamedParameter("opl.attribute", "required") == "true")
    addRequiredAttribute(${plugin.getAttributeConstant($method)});
      #end
    #end
  }
  
  public ${plugin.getDestinationClassname($class)}(OPLContext ctx){
    super(ctx);
    #foreach($method in $class.methods)
      #if($method.getNamedParameter("opl.attribute", "required") == "true")
    addRequiredAttribute(${plugin.getAttributeConstant($method)});
      #end
    #end
  }
  
  protected final void doBeforeChildren(ElementInfo info) throws ParseException{
  #foreach($method in $class.methods)
    #if($method.getNamedParameter("opl.attribute", "before-children") == "true")
      #set($attrName = $method.getNamedParameter("opl.attribute", "name"))
    String $attrName = getAttribute(${plugin.getAttributeConstant($method)}, info, ${method.getNamedParameter("opl.attribute", "resolve-value")});
      #set($extractor = $method.getNamedParameter("opl.attribute", "extractor"))
      #if($extractor)
    if($attrName != null){
      #set($ex = ${extractor.replaceAll("value", "${attrName}")})
      instance.$method.callSignature.replaceAll("param", "${ex}");
    }
      #else
    instance.$method.callSignature.replaceAll("param", "${attrName}");
      #end
    #end
  #end
  }
  
  protected final void doAfterChildren(ElementInfo info, String bodyText) throws ParseException{
  #foreach($method in $class.methods)
    #if($method.getNamedParameter("opl.attribute", "before-children") == "false")
      #set($attrName = $method.getNamedParameter("opl.attribute", "name"))
    String $attrName = getAttribute(${plugin.getAttributeConstant($method)}, info, $method.getNamedParameter("opl.attribute", "resolve-value"));
      #set($extractor = $method.getNamedParameter("opl.attribute", "extractor"))
      #if($extractor)
    if($attrName != null){
      #set($ex = ${extractor.replaceAll("value", "${attrName}")})
      instance.$method.callSignature.replaceAll("param", "${ex}");
    }
      #else
    instance.$method.callSignature.replaceAll("param", "${attrName}");
      #end
    #end
    
  #end
  
  #foreach($childOfTag in $class.getTagsByName("opl.child-of"))
    #set($required = ${childOfTag.getNamedParameter("required")})
    $childOfTag.getNamedParameter("class") container$velocityCount = 
      ($childOfTag.getNamedParameter("class"))findAncestorOfType(
        ${childOfTag.getNamedParameter("class")}.class, ${required}
    );
    #if($required)
    container${velocityCount}.${childOfTag.getNamedParameter("setter").replaceAll("value", "instance")};
    #else
    if(container${velocityCount} != null){
      container${velocityCount}.${childOfTag.getNamedParameter("setter").replaceAll("value", "instance")};
    }
    #end
    
  #end
  }
  
#foreach($method in $class.methods)
  #if($method.getTagByName("opl.delegate"))
  ${method.getDeclarationSignature(true)}{
    instance.${method.callSignature};
  }
  #end
  
#end
#if($class.getNamedParameter("opl.parser", "root") == "true")
  public Object getParsedObject(){
    return instance;
  }

#end  
}

--- NEW FILE: OplXsdPlugin.jelly ---
<?xml version="1.0" encoding="UTF-8"?>
<jelly xmlns="jelly:core" xmlns:x="jelly:xml">
  <x:element name="xs:schema">
    <x:attribute name="xmlns:xs">http://www.w3.org/2001/XMLSchema</x:attribute>
    <x:attribute name="elementFormDefault">qualified</x:attribute>
    <x:attribute name="attributeFormDefault">unqualified</x:attribute>
    <!-- 
    <x:attribute name="targetNamespace">opl:${plugin.library}</x:attribute>
    -->
    <forEach items="${metadata}" var="class">
      <set var="parserDef" value="${class.getTagByName('opl.parser')}"/>
      <if test="${parserDef != null}">
        <if test="${plugin.shouldGenerate(class)}">
          <x:element name="xs:element">
            <x:attribute name="name">${class.getNamedParameter('opl.parser', 'node')}</x:attribute>
            <x:element name="xs:complexType">
              <set var="childTags" value="${class.getTagsByName('opl.parent-of')}"/>
              <if test="${childTags != null and !empty(childTags)}">
                <x:element name="xs:sequence">
                  <forEach var="childTag" items="${childTags}">
                    <x:element name="xs:element">
                      <x:attribute name="ref">${childTag.getNamedParameter('ref')}</x:attribute>
                      <choose>
                        <when test="${childTag.getNamedParameter('minOccurs') != null}">
                          <x:attribute name="minOccurs">${childTag.getNamedParameter('minOccurs')}</x:attribute>
                        </when>
                        <otherwise>
                          <x:attribute name="minOccurs">0</x:attribute>
                        </otherwise>
                      </choose>
                      <choose>
                        <when test="${childTag.getNamedParameter('maxOccurs') != null}">
                          <x:attribute name="maxOccurs">${childTag.getNamedParameter('maxOccurs')}</x:attribute>
                        </when>
                        <otherwise>
                          <x:attribute name="maxOccurs">unbounded</x:attribute>
                        </otherwise>
                      </choose>
                    </x:element>
                  </forEach>
                </x:element>
              </if>
              <forEach var="method" items="${class.methods}">
                <set var="attrTag" value="${method.getTagByName('opl.attribute')}"/>
                <if test="${attrTag != null}">
                  <x:element name="xs:attribute">
                    <x:attribute name="name">${attrTag.getNamedParameter('name')}</x:attribute>
                    <set var="requiredVal" value="${attrTag.getNamedParameter('required')}"/>
                    <choose>
                      <when test="${requiredVal != null}">
                        <choose>
                          <when test="${requiredVal == 'false'}">
                            <x:attribute name="use">optional</x:attribute>
                          </when>
                          <otherwise>
                            <x:attribute name="use">required</x:attribute>
                          </otherwise>
                        </choose>
                      </when>
                      <otherwise>
                        <x:attribute name="use">optional</x:attribute>
                      </otherwise>
                    </choose>
                    <set var="typeVal" value="${attrTag.getNamedParameter('type')}"/>
                    <choose>
                      <when test="${typeVal != null}">
                        <x:attribute name="type">xs:${typeVal}</x:attribute>
                      </when>
                      <otherwise>
                        <x:attribute name="type">xs:string</x:attribute>
                      </otherwise>
                    </choose>
                  </x:element>
                </if>
              </forEach>
            </x:element>
          </x:element>
        </if>
      </if>
    </forEach>
  </x:element>
</jelly>

--- NEW FILE: OplParserLibraryPlugin.jelly ---
<?xml version="1.0" encoding="UTF-8"?>
<jelly xmlns="jelly:core" xmlns:x="jelly:xml">
  <x:element name="parser-library">
    <x:attribute name="xmlns">dynalib</x:attribute>
    <x:attribute name="ignore-unrecognized">${plugin.ignoreunrecognized}</x:attribute>
    <forEach items="${metadata}" var="class">
      <set var="parserDef" value="${class.getTagByName('opl.parser')}"/>
      <if test="${parserDef != null}">
        <if test="${plugin.shouldGenerate(class)}">
          <parser node="${parserDef.getNamedParameter('node')}"
                  class="${class.fullyQualifiedName}Parser"/>
        </if>
      </if>
    </forEach>
  </x:element>
</jelly>

--- NEW FILE: OplXsdPlugin.java ---
/* Created on Mar 6, 2004 */
package org.commonjava.opl.xdoclet;

import org.generama.JellyPlugin;
import org.generama.MetadataProvider;
import org.generama.WriterMapper;
import org.xdoclet.QDoxMetadataProvider;

import com.thoughtworks.qdox.model.JavaClass;

/**
 * @author jdcasey
 */
public class OplXsdPlugin extends JellyPlugin {
  
  private String libraryName;
  private String nsURL;

  /**
   * @param metadataProvider
   * @param writerMapper
   */
  public OplXsdPlugin(MetadataProvider metadataProvider, WriterMapper writerMapper) {
    super(metadataProvider, writerMapper);
    setMultioutput(false);
    setSupressdeclaration(false);
  }
  
  public void setNamespaceurl(String nsURL){
    this.nsURL = nsURL;
  }
  
  public String getNamespaceurl(){
    return nsURL;
  }

  /** Return the library name to be generated. This will result in a &lt;library-name&gt;.opl
   * file being generated.
   * 
   * @return the library name
   */
  public String getLibrary() {
    return libraryName;
  }

  /** Set the library name to be generated. This will result in a &lt;library-name&gt;.opl
   * file being generated.
   * 
   * @param libraryName the library name
   */
  public void setLibrary(String libraryName) {
    this.libraryName = libraryName;
  }

  /** Only generate for NodeParser implementations.
   * @see org.generama.AbstractPlugin#shouldGenerate(java.lang.Object)
   */
  public boolean shouldGenerate(Object metadata) {
    JavaClass jc = (JavaClass)metadata;
    return jc.getTagByName("opl.parser") != null;
  }

  /** Override to pre-set the file to generate.
   * @see org.picocontainer.Startable#start()
   */
  public void start() {
    setFilereplace(libraryName + ".xsd");
    super.start();
  }

}

--- NEW FILE: OplParserLibraryPlugin.java ---
/* Created on Mar 5, 2004 */
package org.commonjava.opl.xdoclet;

import org.generama.JellyPlugin;
import org.generama.MetadataProvider;
import org.generama.WriterMapper;

import com.thoughtworks.qdox.model.JavaClass;

/**
 * @author jdcasey
 */
public class OplParserLibraryPlugin extends JellyPlugin {
  
  private String libraryName;
  private String ignoreUnrecognized = "false";

  /**
   * @param metadataProvider
   * @param writerMapper
   */
  public OplParserLibraryPlugin(MetadataProvider metadataProvider, WriterMapper writerMapper) {
    super(metadataProvider, writerMapper);
    setMultioutput(false);
    setSupressdeclaration(false);
  }

  /** Return the library name to be generated. This will result in a &lt;library-name&gt;.opl
   * file being generated.
   * 
   * @return the library name
   */
  public String getLibrary() {
    return libraryName;
  }

  /** Set the library name to be generated. This will result in a &lt;library-name&gt;.opl
   * file being generated.
   * 
   * @param libraryName the library name
   */
  public void setLibrary(String libraryName) {
    this.libraryName = libraryName;
  }
  
  public void setIgnoreunrecognized(String ignore){
    this.ignoreUnrecognized = ignore;
  }
  
  public String getIgnoreunrecognized(){
    return ignoreUnrecognized;
  }

  /** Only generate for NodeParser implementations.
   * @see org.generama.AbstractPlugin#shouldGenerate(java.lang.Object)
   */
  public boolean shouldGenerate(Object metadata) {
    JavaClass jc = (JavaClass)metadata;
    return jc.getTagByName("opl.parser") != null;
  }

  /** Override to pre-set the file to generate.
   * @see org.picocontainer.Startable#start()
   */
  public void start() {
    setFilereplace(libraryName + ".opl");
    super.start();
  }

}