Author: spagop Date: 2008-07-26 17:33:14 -0400 (Sat, 26 Jul 2008) New Revision: 372 Modified: trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/AbstractJavaMetadata.java trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/JavaMetadataSequencer.java trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/metadata/ClassMetadata.java trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/metadata/ConstructorMetadata.java trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/metadata/JavaMetadata.java trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/metadata/MethodMetadata.java trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/metadata/ParameterizedFieldMetadata.java trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/metadata/TypeMetadata.java trunk/sequencers/dna-sequencer-java/src/main/resources/org/jboss/dna/sequencer/java/java-source-artifact.cnd trunk/sequencers/dna-sequencer-java/src/test/java/org/jboss/dna/sequencer/java/JavaMetadataSequencerTest.java trunk/sequencers/dna-sequencer-java/src/test/java/org/jboss/dna/sequencer/java/JavaMetadataTest.java trunk/sequencers/dna-sequencer-java/src/test/workspace/projectX/src/org/acme/MySource.java Log: minimal enhancement for the sequencer (imports,fields, methods). Take the support of same-name siblings with index in consideration Modified: trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/AbstractJavaMetadata.java =================================================================== --- trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/AbstractJavaMetadata.java 2008-07-25 20:39:42 UTC (rev 371) +++ trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/AbstractJavaMetadata.java 2008-07-26 21:33:14 UTC (rev 372) @@ -155,6 +155,7 @@ protected List<TypeMetadata> createTypeMetadata( CompilationUnit unit ) { List<TypeMetadata> metadata = new ArrayList<TypeMetadata>(); List<AbstractTypeDeclaration> topLevelType = unit.types(); + for (AbstractTypeDeclaration abstractTypeDeclaration : topLevelType) { // process TypeDeclaration (class, interface) if (abstractTypeDeclaration instanceof TypeDeclaration) { @@ -192,7 +193,7 @@ // methods of the class top level type MethodDeclaration[] methodDeclarations = typeDeclaration.getMethods(); for (MethodDeclaration methodDeclaration : methodDeclarations) { - MethodMetadata methodMetadata = getFieldMetadataFrom(methodDeclaration); + MethodMetadata methodMetadata = getMethodMetadataFrom(methodDeclaration); classMetadata.getMethods().add(methodMetadata); } metadata.add(classMetadata); @@ -220,7 +221,7 @@ * @param methodDeclaration - the MethodDeclaration. * @return methodMetadata - the method meta data. */ - private MethodMetadata getFieldMetadataFrom( MethodDeclaration methodDeclaration ) { + private MethodMetadata getMethodMetadataFrom( MethodDeclaration methodDeclaration ) { if (methodDeclaration != null) { if (methodDeclaration.isConstructor()) { return getConstructorMetadataFrom(methodDeclaration); Modified: trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/JavaMetadataSequencer.java =================================================================== --- trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/JavaMetadataSequencer.java 2008-07-25 20:39:42 UTC (rev 371) +++ trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/JavaMetadataSequencer.java 2008-07-26 21:33:14 UTC (rev 372) @@ -24,14 +24,27 @@ import java.io.IOException; import java.io.InputStream; import java.util.List; +import java.util.Map; import org.apache.commons.lang.StringUtils; import org.jboss.dna.common.monitor.ProgressMonitor; import org.jboss.dna.sequencer.java.metadata.AnnotationMetadata; +import org.jboss.dna.sequencer.java.metadata.ClassMetadata; +import org.jboss.dna.sequencer.java.metadata.ConstructorMetadata; +import org.jboss.dna.sequencer.java.metadata.FieldMetadata; +import org.jboss.dna.sequencer.java.metadata.ImportMetadata; +import org.jboss.dna.sequencer.java.metadata.ImportOnDemandMetadata; import org.jboss.dna.sequencer.java.metadata.JavaMetadata; import org.jboss.dna.sequencer.java.metadata.MarkerAnnotationMetadata; +import org.jboss.dna.sequencer.java.metadata.MethodMetadata; +import org.jboss.dna.sequencer.java.metadata.MethodTypeMemberMetadata; import org.jboss.dna.sequencer.java.metadata.NormalAnnotationMetadata; import org.jboss.dna.sequencer.java.metadata.PackageMetadata; +import org.jboss.dna.sequencer.java.metadata.ParameterizedFieldMetadata; +import org.jboss.dna.sequencer.java.metadata.PrimitiveFieldMetadata; +import org.jboss.dna.sequencer.java.metadata.SingleImportMetadata; import org.jboss.dna.sequencer.java.metadata.SingleMemberAnnotationMetadata; +import org.jboss.dna.sequencer.java.metadata.TypeMetadata; +import org.jboss.dna.sequencer.java.metadata.Variable; import org.jboss.dna.spi.graph.NameFactory; import org.jboss.dna.spi.graph.Path; import org.jboss.dna.spi.graph.PathFactory; @@ -47,22 +60,79 @@ * <ul> * <li><strong>java:compilationUnit</strong> node of type <code>java:compilationUnit</code> * <ul> - * <li><strong>java:package</strong> - optional child node that represents the package declaration of the compilation unit</li> + * <li> <strong>java:package</strong> - optional child node that represents the package child node of the compilation unit + * <ul> + * <li> <strong>java:packageDeclaration</strong> - + * <ul> + * <li><strong>java:packageName</strong></li> * </ul> * </li> * </ul> + * </li> + * <li> <strong>java:import</strong> - optional child node that represents the import declaration of the compilation unit + * <ul> + * <li> <strong>java:importDeclaration</strong> - + * <ul> + * <li> <strong>java:singleTypeImportDeclaration</strong> + * <ul> + * <li> <strong>java:packageDeclaration</strong> - + * <ul> + * <li><strong>java:typeName</strong></li> + * </ul> + * </li> + * </ul> + * </li> + * <li> <strong>java:typeImportOnDemandDeclaration</strong> + * <ul> + * <li> <strong>java:packageDeclaration</strong> - + * <ul> + * <li><strong>java:typeName</strong></li> + * </ul> + * </li> + * </ul> + * </li> + * </ul> + * </li> + * </ul> + * </li> + * <li><strong>java:unitType</strong> - optional child node that represents the top level type (class, interface, enum, + * annotation) declaration of the compilation unit</li> + * <ul> + * <li> <strong>java:classDeclaration</strong> - optional child node that represents the class declaration of the compilation + * unit + * <ul> + * <li> <strong>java:normalClass</strong> - + * <ul> + * <li> <strong>java:normalClassDeclaration</strong> - + * <ul> + * <li> <strong>java:modifier</strong> - </li> + * <li> <strong>java:name</strong> - </li> + * <li> <strong>java:field</strong> - </li> + * <li> <strong>java:method</strong> - </li> + * <li> <strong>java:constructor</strong> - </li> + * </ul> + * </li> + * </ul> + * </li> + * </ul> + * </li> + * </ul> + * </li> + * </ul> * </p> * * @author Serge Pagop */ public class JavaMetadataSequencer implements StreamSequencer { + private static final String SLASH = "/"; + public static final String JAVA_COMPILATION_UNIT_NODE = "java:compilationUnit"; public static final String JAVA_COMPILATION_UNIT_PRIMARY_TYPE = "jcr:primaryType"; + // package declaration public static final String JAVA_PACKAGE_CHILD_NODE = "java:package"; public static final String JAVA_PACKAGE_DECLARATION_CHILD_NODE = "java:packageDeclaration"; public static final String JAVA_PACKAGE_NAME = "java:packageName"; - // Annnotation declaration public static final String JAVA_ANNOTATION_CHILD_NODE = "java:annotation"; public static final String JAVA_ANNOTATION_DECLARATION_CHILD_NODE = "java:annotationDeclaration"; @@ -71,19 +141,40 @@ public static final String JAVA_NORMAL_ANNOTATION_CHILD_NODE = "java:normalAnnotation"; public static final String JAVA_SINGLE_ELEMENT_ANNOTATION_CHILD_NODE = "java:singleElementAnnotation"; public static final String JAVA_ANNOTATION_TYPE_NAME = "java:typeName"; - // Import declaration public static final String JAVA_IMPORT_CHILD_NODE = "java:import"; public static final String JAVA_IMPORT_DECLARATION_CHILD_NODE = "java:importDeclaration"; public static final String JAVA_SINGLE_IMPORT_CHILD_NODE = "java:singleImport"; public static final String JAVA_SINGLE_TYPE_IMPORT_DECLARATION_CHILD_NODE = "java:singleTypeImportDeclaration"; - public static final String JAVA_IMPORT_ON_DEMAND_CHILD_NODE = "java:importOnDemand"; public static final String JAVA_TYPE_IMPORT_ON_DEMAND_DECLARATION_CHILD_NODE = "java:typeImportOnDemandDeclaration"; - public static final String JAVA_IMPORT_TYPE_NAME = "typeName"; + public static final String JAVA_IMPORT_TYPE_NAME = "java:typeName"; + // normal class declaration + public static final String JAVA_UNIT_TYPE_CHILD_NODE = "java:unitType"; + public static final String JAVA_CLASS_DECLARATION_CHILD_NODE = "java:classDeclaration"; + public static final String JAVA_NORMAL_CLASS_CHILD_NODE = "java:normalClass"; + public static final String JAVA_NORMAL_CLASS_DECLARATION_CHILD_NODE = "java:normalClassDeclaration"; + public static final String JAVA_CLASS_NAME = "java:name"; + public static final String JAVA_PUBLIC_CLASS_MODIFIER = "java:modifier"; - private static final String SLASH = "/"; - + public static final String JAVA_TYPE_NAME = "java:name"; + // primitive type + public static final String JAVA_FIELD_CHILD_NODE = "java:field"; + public static final String JAVA_FIELD_TYPE_CHILD_NODE = "java:fieldType"; + public static final String JAVA_TYPE_CHILD_NODE = "java:type"; + public static final String JAVA_PRIMITIVE_TYPE_CHILD_NODE = "java:primitiveType"; + + // reference type + public static final String JAVA_REFERENCE_TYPE_CHILD_NODE = "java:referenceType"; + + // method declaration + public static final String JAVA_METHOD_CHILD_NODE = "java:method"; + public static final String JAVA_METHOD_DECLARATION_CHILD_NODE = "java:methodDeclaration"; + public static final String JAVA_METHOD_NAME = "java:name"; + + public static final String JAVA_CONSTRUCTOR_CHILD_NODE = "java:constructor"; + public static final String JAVA_CONSTRUCTOR_DECLARATION_CHILD_NODE = "java:constructorDeclaration"; + /** * {@inheritDoc} * @@ -114,11 +205,11 @@ nameFactory.create(JAVA_COMPILATION_UNIT_PRIMARY_TYPE), "java:compilationUnit"); - // Process package declaration of a unit. + // sequence package declaration of a unit. PackageMetadata packageMetadata = javaMetadata.getPackageMetadata(); if (packageMetadata != null) { if (StringUtils.isNotEmpty(packageMetadata.getName())) { - + Path javaPackageDeclarationChildNode = pathFactory.create(JAVA_COMPILATION_UNIT_NODE + SLASH + JAVA_PACKAGE_CHILD_NODE + SLASH + JAVA_PACKAGE_DECLARATION_CHILD_NODE); @@ -128,58 +219,185 @@ } List<AnnotationMetadata> annotations = packageMetadata.getAnnotationMetada(); - if (!annotations.isEmpty()) { - for (AnnotationMetadata annotationMetadata : annotations) { - if (annotationMetadata instanceof MarkerAnnotationMetadata) { - MarkerAnnotationMetadata markerAnnotationMetadata = (MarkerAnnotationMetadata)annotationMetadata; - Path markerAnnotationChildNode = pathFactory.create(JAVA_COMPILATION_UNIT_NODE + SLASH - + JAVA_PACKAGE_CHILD_NODE + SLASH - + JAVA_PACKAGE_DECLARATION_CHILD_NODE + SLASH - + JAVA_ANNOTATION_CHILD_NODE + SLASH - + JAVA_ANNOTATION_DECLARATION_CHILD_NODE + SLASH - + JAVA_ANNOTATION_TYPE_CHILD_NODE + SLASH - + JAVA_MARKER_ANNOTATION_CHILD_NODE); - output.setProperty(markerAnnotationChildNode, - nameFactory.create(JAVA_ANNOTATION_TYPE_NAME), - markerAnnotationMetadata.getName()); + int markerAnnotationIndex = 1; + int singleAnnatationIndex = 1; + int normalAnnotationIndex = 1; + for (AnnotationMetadata annotationMetadata : annotations) { + if (annotationMetadata instanceof MarkerAnnotationMetadata) { + MarkerAnnotationMetadata markerAnnotationMetadata = (MarkerAnnotationMetadata)annotationMetadata; + Path markerAnnotationChildNode = pathFactory.create(JAVA_COMPILATION_UNIT_NODE + SLASH + + JAVA_PACKAGE_CHILD_NODE + SLASH + + JAVA_PACKAGE_DECLARATION_CHILD_NODE + SLASH + + JAVA_ANNOTATION_CHILD_NODE + SLASH + + JAVA_ANNOTATION_DECLARATION_CHILD_NODE + SLASH + + JAVA_ANNOTATION_TYPE_CHILD_NODE + SLASH + + JAVA_MARKER_ANNOTATION_CHILD_NODE + "[" + + markerAnnotationIndex + "]"); + output.setProperty(markerAnnotationChildNode, + nameFactory.create(JAVA_ANNOTATION_TYPE_NAME), + markerAnnotationMetadata.getName()); + markerAnnotationIndex++; + } + if (annotationMetadata instanceof SingleMemberAnnotationMetadata) { + SingleMemberAnnotationMetadata singleMemberAnnotationMetadata = (SingleMemberAnnotationMetadata)annotationMetadata; + Path singleMemberAnnotationChildNode = pathFactory.create(JAVA_COMPILATION_UNIT_NODE + SLASH + + JAVA_PACKAGE_CHILD_NODE + SLASH + + JAVA_PACKAGE_DECLARATION_CHILD_NODE + SLASH + + JAVA_ANNOTATION_CHILD_NODE + SLASH + + JAVA_ANNOTATION_DECLARATION_CHILD_NODE + + SLASH + JAVA_ANNOTATION_TYPE_CHILD_NODE + + SLASH + + JAVA_SINGLE_ELEMENT_ANNOTATION_CHILD_NODE + + "[" + singleAnnatationIndex + "]"); + output.setProperty(singleMemberAnnotationChildNode, + nameFactory.create(JAVA_ANNOTATION_TYPE_NAME), + singleMemberAnnotationMetadata.getName()); + singleAnnatationIndex++; + } + if (annotationMetadata instanceof NormalAnnotationMetadata) { + NormalAnnotationMetadata normalAnnotationMetadata = (NormalAnnotationMetadata)annotationMetadata; + Path normalAnnotationChildNode = pathFactory.create(JAVA_COMPILATION_UNIT_NODE + SLASH + + JAVA_PACKAGE_CHILD_NODE + SLASH + + JAVA_PACKAGE_DECLARATION_CHILD_NODE + SLASH + + JAVA_ANNOTATION_CHILD_NODE + SLASH + + JAVA_ANNOTATION_DECLARATION_CHILD_NODE + SLASH + + JAVA_ANNOTATION_TYPE_CHILD_NODE + SLASH + + JAVA_NORMAL_ANNOTATION_CHILD_NODE + "[" + + normalAnnotationIndex + "]"); + + output.setProperty(normalAnnotationChildNode, + nameFactory.create(JAVA_ANNOTATION_TYPE_NAME), + normalAnnotationMetadata.getName()); + normalAnnotationIndex++; + } + } + } + + // sequence import declarations of a unit + List<ImportMetadata> imports = javaMetadata.getImports(); + int importOnDemandIndex = 1; + int singleImportIndex = 1; + for (ImportMetadata importMetadata : imports) { + if (importMetadata instanceof ImportOnDemandMetadata) { + ImportOnDemandMetadata importOnDemandMetadata = (ImportOnDemandMetadata)importMetadata; + Path importOnDemandChildNode = pathFactory.create(JAVA_COMPILATION_UNIT_NODE + SLASH + JAVA_IMPORT_CHILD_NODE + + SLASH + JAVA_IMPORT_DECLARATION_CHILD_NODE + SLASH + + JAVA_IMPORT_ON_DEMAND_CHILD_NODE + SLASH + + JAVA_TYPE_IMPORT_ON_DEMAND_DECLARATION_CHILD_NODE + "[" + + importOnDemandIndex + "]"); + output.setProperty(importOnDemandChildNode, + nameFactory.create(JAVA_IMPORT_TYPE_NAME), + importOnDemandMetadata.getName()); + importOnDemandIndex++; + } + if (importMetadata instanceof SingleImportMetadata) { + SingleImportMetadata singleImportMetadata = (SingleImportMetadata)importMetadata; + Path singleImportChildNode = pathFactory.create(JAVA_COMPILATION_UNIT_NODE + SLASH + JAVA_IMPORT_CHILD_NODE + + SLASH + JAVA_IMPORT_DECLARATION_CHILD_NODE + SLASH + + JAVA_SINGLE_IMPORT_CHILD_NODE + SLASH + + JAVA_SINGLE_TYPE_IMPORT_DECLARATION_CHILD_NODE + "[" + + singleImportIndex + "]"); + output.setProperty(singleImportChildNode, + nameFactory.create(JAVA_IMPORT_TYPE_NAME), + singleImportMetadata.getName()); + singleImportIndex++; + } + } + + // sequence type declaration (class declaration) information + List<TypeMetadata> types = javaMetadata.getTypeMetadata(); + for (TypeMetadata typeMetadata : types) { + // class declaration + if (typeMetadata instanceof ClassMetadata) { + ClassMetadata classMetadata = (ClassMetadata)typeMetadata; + Path classChildNode = pathFactory.create(JAVA_COMPILATION_UNIT_NODE + SLASH + JAVA_UNIT_TYPE_CHILD_NODE + + SLASH + JAVA_CLASS_DECLARATION_CHILD_NODE + SLASH + + JAVA_NORMAL_CLASS_CHILD_NODE + SLASH + + JAVA_NORMAL_CLASS_DECLARATION_CHILD_NODE); + output.setProperty(classChildNode, nameFactory.create(JAVA_CLASS_NAME), classMetadata.getName()); + + // process modifiers of the class declaration + Map<Integer, String> classModifiers = classMetadata.getModifiers(); + if (!classModifiers.isEmpty()) { + String publicModifier = classModifiers.get(TypeMetadata.PUBLIC_MODIFIER); + if (publicModifier != null) { + output.setProperty(classChildNode, nameFactory.create(JAVA_PUBLIC_CLASS_MODIFIER), publicModifier); } - if (annotationMetadata instanceof SingleMemberAnnotationMetadata) { - SingleMemberAnnotationMetadata singleMemberAnnotationMetadata = (SingleMemberAnnotationMetadata)annotationMetadata; - Path singleMemberAnnotationChildNode = pathFactory.create(JAVA_COMPILATION_UNIT_NODE + SLASH - + JAVA_PACKAGE_CHILD_NODE + SLASH - + JAVA_PACKAGE_DECLARATION_CHILD_NODE - + SLASH + JAVA_ANNOTATION_CHILD_NODE - + SLASH - + JAVA_ANNOTATION_DECLARATION_CHILD_NODE - + SLASH + JAVA_ANNOTATION_TYPE_CHILD_NODE - + SLASH - + JAVA_SINGLE_ELEMENT_ANNOTATION_CHILD_NODE); - output.setProperty(singleMemberAnnotationChildNode, - nameFactory.create(JAVA_ANNOTATION_TYPE_NAME), - singleMemberAnnotationMetadata.getName()); + } + // process fields of the class unit. + List<FieldMetadata> fields = classMetadata.getFields(); + int primitiveIndex = 1; + for (FieldMetadata fieldMetadata : fields) { + if (fieldMetadata instanceof PrimitiveFieldMetadata) { + PrimitiveFieldMetadata primitiveFieldMetadata = (PrimitiveFieldMetadata)fieldMetadata; + List<Variable> variables = primitiveFieldMetadata.getVariables(); + for (Variable variable : variables) { + Path primitiveChildNode = pathFactory.create(JAVA_COMPILATION_UNIT_NODE + SLASH + + JAVA_UNIT_TYPE_CHILD_NODE + SLASH + + JAVA_CLASS_DECLARATION_CHILD_NODE + SLASH + + JAVA_NORMAL_CLASS_CHILD_NODE + SLASH + + JAVA_NORMAL_CLASS_DECLARATION_CHILD_NODE + SLASH + + JAVA_FIELD_CHILD_NODE + SLASH + + JAVA_FIELD_TYPE_CHILD_NODE + SLASH + + JAVA_TYPE_CHILD_NODE + SLASH + + JAVA_PRIMITIVE_TYPE_CHILD_NODE + "[" + + primitiveIndex + "]"); + output.setProperty(primitiveChildNode, nameFactory.create(JAVA_TYPE_NAME), variable.getName()); + primitiveIndex++; + } } - if (annotationMetadata instanceof NormalAnnotationMetadata) { - NormalAnnotationMetadata normalAnnotationMetadata = (NormalAnnotationMetadata)annotationMetadata; - Path normalAnnotationChildNode = pathFactory.create(JAVA_COMPILATION_UNIT_NODE + SLASH - + JAVA_PACKAGE_CHILD_NODE + SLASH - + JAVA_PACKAGE_DECLARATION_CHILD_NODE + SLASH - + JAVA_ANNOTATION_CHILD_NODE + SLASH - + JAVA_ANNOTATION_DECLARATION_CHILD_NODE + SLASH - + JAVA_ANNOTATION_TYPE_CHILD_NODE + SLASH - + JAVA_NORMAL_ANNOTATION_CHILD_NODE); - - - output.setProperty(normalAnnotationChildNode, - nameFactory.create(JAVA_ANNOTATION_TYPE_NAME), - normalAnnotationMetadata.getName()); + if (fieldMetadata instanceof ParameterizedFieldMetadata) { + ParameterizedFieldMetadata parameterizedFieldMetadata = (ParameterizedFieldMetadata)fieldMetadata; + // TODO } } + + // process methods of the unit. + List<MethodMetadata> methods = classMetadata.getMethods(); + int methodIndex = 1; + int constructorIndex = 1; + for (MethodMetadata methodMetadata : methods) { + if (methodMetadata.isContructor()) { + // process contructor + ConstructorMetadata constructorMetadata = (ConstructorMetadata)methodMetadata; + + Path constructorChildNode = pathFactory.create(JAVA_COMPILATION_UNIT_NODE + SLASH + + JAVA_UNIT_TYPE_CHILD_NODE + SLASH + + JAVA_CLASS_DECLARATION_CHILD_NODE + SLASH + + JAVA_NORMAL_CLASS_CHILD_NODE + SLASH + + JAVA_NORMAL_CLASS_DECLARATION_CHILD_NODE + SLASH + + JAVA_CONSTRUCTOR_CHILD_NODE + SLASH + + JAVA_CONSTRUCTOR_DECLARATION_CHILD_NODE + "[" + + constructorIndex + "]"); + output.setProperty(constructorChildNode, + nameFactory.create(JAVA_METHOD_NAME), + constructorMetadata.getName()); + constructorIndex++; + } else { + + // normal method + MethodTypeMemberMetadata methodTypeMemberMetadata = (MethodTypeMemberMetadata)methodMetadata; + Path methodChildNode = pathFactory.create(JAVA_COMPILATION_UNIT_NODE + SLASH + + JAVA_UNIT_TYPE_CHILD_NODE + SLASH + + JAVA_CLASS_DECLARATION_CHILD_NODE + SLASH + + JAVA_NORMAL_CLASS_CHILD_NODE + SLASH + + JAVA_NORMAL_CLASS_DECLARATION_CHILD_NODE + SLASH + + JAVA_METHOD_CHILD_NODE + SLASH + + JAVA_METHOD_DECLARATION_CHILD_NODE + "[" + methodIndex + + "]"); + output.setProperty(methodChildNode, + nameFactory.create(JAVA_METHOD_NAME), + methodTypeMemberMetadata.getName()); + methodIndex++; + } + } } + // interface declaration + + // enumeration declaration } + } - // Process import declarations of a unit - //TODO write BDD to show how the works - } progressMonitor.done(); } } Modified: trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/metadata/ClassMetadata.java =================================================================== --- trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/metadata/ClassMetadata.java 2008-07-25 20:39:42 UTC (rev 371) +++ trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/metadata/ClassMetadata.java 2008-07-26 21:33:14 UTC (rev 372) @@ -21,7 +21,6 @@ */ package org.jboss.dna.sequencer.java.metadata; -import java.util.List; /** Modified: trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/metadata/ConstructorMetadata.java =================================================================== --- trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/metadata/ConstructorMetadata.java 2008-07-25 20:39:42 UTC (rev 371) +++ trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/metadata/ConstructorMetadata.java 2008-07-26 21:33:14 UTC (rev 372) @@ -26,4 +26,16 @@ */ public class ConstructorMetadata extends MethodMetadata { + public ConstructorMetadata() { + } + + /** + * {@inheritDoc} + * + * @see org.jboss.dna.sequencer.java.metadata.MethodMetadata#isContructor() + */ + @Override + public boolean isContructor() { + return true; + } } Modified: trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/metadata/JavaMetadata.java =================================================================== --- trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/metadata/JavaMetadata.java 2008-07-25 20:39:42 UTC (rev 371) +++ trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/metadata/JavaMetadata.java 2008-07-26 21:33:14 UTC (rev 372) @@ -33,17 +33,16 @@ * @author Serge Pagop */ public class JavaMetadata extends AbstractJavaMetadata { - + /** The package representation of a compilation unit. */ private PackageMetadata packageMetadata; - + /** All the import declarations of a compilation unit. */ - private List<ImportMetadata> importMetadata; - - /** variables */ - - /** methods */ + private List<ImportMetadata> imports; + /** Types of unit */ + private List<TypeMetadata> types; + private JavaMetadata() { } @@ -75,14 +74,16 @@ CompilationUnit unit = (CompilationUnit)CompilationUnitParser.runJLS3Conversion(source, true); if (unit != null) { javaMetadata.packageMetadata = javaMetadata.createPackageMetadata(unit); - javaMetadata.importMetadata = javaMetadata.createImportMetadata(unit); + javaMetadata.imports = javaMetadata.createImportMetadata(unit); + javaMetadata.types = javaMetadata.createTypeMetadata(unit); + } return javaMetadata; } /** - * Gets the <code>PackageMetadata</code>. + * Gets the {@link PackageMetadata} from the unit. * * @return the PackageMetadata or null if there is not package declaration for the unit. */ @@ -91,11 +92,20 @@ } /** - * Gets a list of <code>ImportMetadata</code>. + * Gets a list of {@linkImportMetadata} from the unit. * - * @return all the importMetadata of this unit if there is one. + * @return all imports of this unit if there is one. */ - public List<ImportMetadata> getImportMetadata() { - return importMetadata; + public List<ImportMetadata> getImports() { + return imports; } + + /** + * Gets the list for type declarations (class/interface/enum/annotation) of this unit. + * + * @return all typeMetadata of this unit. + */ + public List<TypeMetadata> getTypeMetadata() { + return types; + } } Modified: trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/metadata/MethodMetadata.java =================================================================== --- trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/metadata/MethodMetadata.java 2008-07-25 20:39:42 UTC (rev 371) +++ trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/metadata/MethodMetadata.java 2008-07-26 21:33:14 UTC (rev 372) @@ -26,7 +26,6 @@ */ public class MethodMetadata { private String name; - /** * @return name */ @@ -40,5 +39,11 @@ public void setName( String name ) { this.name = name; } - + + /** + * @return isContructor + */ + public boolean isContructor() { + return false; + } } Modified: trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/metadata/ParameterizedFieldMetadata.java =================================================================== --- trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/metadata/ParameterizedFieldMetadata.java 2008-07-25 20:39:42 UTC (rev 371) +++ trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/metadata/ParameterizedFieldMetadata.java 2008-07-26 21:33:14 UTC (rev 372) @@ -21,7 +21,6 @@ */ package org.jboss.dna.sequencer.java.metadata; -import java.util.List; /** * Field meta data for parameterized type. Modified: trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/metadata/TypeMetadata.java =================================================================== --- trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/metadata/TypeMetadata.java 2008-07-25 20:39:42 UTC (rev 371) +++ trunk/sequencers/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/metadata/TypeMetadata.java 2008-07-26 21:33:14 UTC (rev 372) @@ -83,6 +83,7 @@ } /** + * * @return modifiers */ public Map<Integer, String> getModifiers() { @@ -97,7 +98,9 @@ } /** - * @return fields of this top level unit. + * Gets a ordered lists of {@link FieldMetadata} from the unit. + * + * @return all fields of this unit if there is one. */ public List<FieldMetadata> getFields() { return this.fields; @@ -111,7 +114,9 @@ } /** - * @return methods of this top level unit. + * Gets all {@link MethodMetadata} from the unit. + * + * @return all methods from the units. */ public List<MethodMetadata> getMethods() { return methods; Modified: trunk/sequencers/dna-sequencer-java/src/main/resources/org/jboss/dna/sequencer/java/java-source-artifact.cnd =================================================================== --- trunk/sequencers/dna-sequencer-java/src/main/resources/org/jboss/dna/sequencer/java/java-source-artifact.cnd 2008-07-25 20:39:42 UTC (rev 371) +++ trunk/sequencers/dna-sequencer-java/src/main/resources/org/jboss/dna/sequencer/java/java-source-artifact.cnd 2008-07-26 21:33:14 UTC (rev 372) @@ -108,51 +108,38 @@ - java:name (string) + java:type (java:primitiveType, java:referenceType) mandatory multiple -/** - * No Return type - */ -[java:noReturnType] > nt:unstructured - - java:noReturn (string) - < 'void' - -/** - * Integral type - */ -[java:integralType] > nt:unstructured - - java:predefinedIntegralType (string) mandatory - < 'byte', 'short', 'int', 'long', 'char' - -/** - * Floating point type - */ -[java:floatingPointType] > nt:unstructured - - java:predefinedFloatingType (string) mandatory - < 'float', 'double' - /** - * Primitive type + * Primitive type: + * - Integral type ('byte', 'short', 'int', 'long', 'char') + * - Floating point type ('float', 'double') + * - Boolean type ('boolean') + * - No return type (''void') */ [java:primitiveType] > nt:unstructured - - java:booleanType (string) - < 'boolean' - + java:numericType (java:integralType, java:floatingPointType) + - java:description (string) + - java:modifier (string) + < 'public', 'protected', 'private' + - java:declaredAs (string) multiple + < 'static','final', 'transient', 'volatile' + - java:type (string) + < 'byte','short','char','int,'long','float','double','boolean','void' + - java:name (string) mandatory - /** * Reference type (TODO to enhance) */ [java:referenceType] > nt:unstructured - -/** - * Field type - */ -[java:fieldType] > nt:unstructured - - java:description (string) +- java:description (string) - java:modifier (string) - < 'public', 'protected', 'private' + < 'public', 'protected', 'private' - java:declaredAs (string) multiple < 'static','final', 'transient', 'volatile' - java:name (string) mandatory + +/** + * Field type + */ +[java:fieldType] > nt:unstructured + java:type (java:primitiveType, java:referenceType) mandatory multiple /** @@ -162,7 +149,7 @@ - java:description (string) - java:modifier (string) < 'public', 'protected', 'private' - + java:resultType (java:noReturnType, java:primitiveType, java:referenceType) mandatory + + java:resultType (java:primitiveType, java:referenceType) mandatory - java:name (string) mandatory - java:declaredAs (string) multiple < 'static','final', 'native', 'strictfp', 'synchronized' @@ -192,14 +179,14 @@ * Import declarations */ [java:singleTypeImportDeclaration] > nt:unstructured - - keyword (string) mandatory + - java:keyword (string) mandatory < 'import' - - typeName (string) mandatory + - java:typeName (string) mandatory [java:typeImportOnDemandDeclaration] > nt:unstructured - - keyword (string) mandatory + - java:keyword (string) mandatory < 'import' - - typeName (string) mandatory + - java:typeName (string) mandatory [java:importDeclaration] > nt:unstructured + java:singleImport (java:singleTypeImportDeclaration) = java:singleTypeImportDeclaration @@ -244,4 +231,4 @@ [java:compilationUnit] > nt:unstructured + java:package (java:packageDeclaration) = java:packageDeclaration + java:import (java:importDeclaration) = java:importDeclaration - + java:type (java:classDeclaration, java:interfaceDeclaration) \ No newline at end of file + + java:unitType (java:classDeclaration, java:interfaceDeclaration) \ No newline at end of file Modified: trunk/sequencers/dna-sequencer-java/src/test/java/org/jboss/dna/sequencer/java/JavaMetadataSequencerTest.java =================================================================== --- trunk/sequencers/dna-sequencer-java/src/test/java/org/jboss/dna/sequencer/java/JavaMetadataSequencerTest.java 2008-07-25 20:39:42 UTC (rev 371) +++ trunk/sequencers/dna-sequencer-java/src/test/java/org/jboss/dna/sequencer/java/JavaMetadataSequencerTest.java 2008-07-26 21:33:14 UTC (rev 372) @@ -84,13 +84,67 @@ assertThat(content, is(notNullValue())); sequencer.sequence(content, output, context, progress); assertThat(output.getPropertyValues("java:compilationUnit", "jcr:primaryType"), is(new Object[] {"java:compilationUnit"})); + + // sequencing package assertThat(output.getPropertyValues("java:compilationUnit/java:package/java:packageDeclaration", "java:packageName"), is(new Object[] {"org.acme"})); - // TODO (find a solution to get the annotation of a package) - // assertThat(output.getPropertyValues("java:compilationUnit/java:package/java:packageDeclaration/java:annotation/java:annotationDeclaration/java:annotationType/java:markerAnnotation", + + // TODO (find a solution to get the annotation of a package). Java Sequencer does not yet support sequencing of + // package-info.java with package annotations + // assertThat(output.getPropertyValues("java:compilationUnit/java:package/java:packageDeclaration/java:annotation/java:annotationDeclaration/java:annotationType/java:markerAnnotation[1]", // "java:typeName"), // is(new Object[] {"org.acme.annotation.MyPackageAnnotation"})); + // sequence imports + assertThat(output.getPropertyValues("java:compilationUnit/java:import/java:importDeclaration/java:singleImport/java:singleTypeImportDeclaration[1]", + "java:typeName"), + is(new Object[] {"org.acme.annotation.MyClassAnnotation"})); + assertThat(output.getPropertyValues("java:compilationUnit/java:import/java:importDeclaration/java:importOnDemand/java:typeImportOnDemandDeclaration[1]", + "java:typeName"), + is(new Object[] {"java.util"})); + + // sequence class definition + assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration", + "java:modifier"), + is(new Object[] {"public"})); + assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration", + "java:name"), + is(new Object[] {"MySource"})); + + // sequence fields + assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:field/java:fieldType/java:type/java:primitiveType[1]", + "java:name"), + is(new Object[] {"i"})); + assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:field/java:fieldType/java:type/java:primitiveType[2]", + "java:name"), + is(new Object[] {"j"})); + assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:field/java:fieldType/java:type/java:primitiveType[3]", + "java:name"), + is(new Object[] {"a"})); + // assertThat(output.getPropertyValues("java:compilationUnit/java:type/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:field/java:fieldType/java:type/java:referenceType", + // "java:name"), + // is(new Object[] {"l"})); + // assertThat(output.getPropertyValues("java:compilationUnit/java:type/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:field/java:fieldType/java:type/java:referenceType", + // "java:name"), + // is(new Object[] {"o"})); + // assertThat(output.getPropertyValues("java:compilationUnit/java:type/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:field/java:fieldType/java:type/java:referenceType", + // "java:name"), + // is(new Object[] {"x"})); + + assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:constructor/java:constructorDeclaration[1]", + "java:name"), + is(new Object[] {"MySource"})); + + assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[1]", + "java:name"), + is(new Object[] {"getI"})); + assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[2]", + "java:name"), + is(new Object[] {"setI"})); + assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[4]", + "java:name"), + is(new Object[] {"doSomething"})); + } } Modified: trunk/sequencers/dna-sequencer-java/src/test/java/org/jboss/dna/sequencer/java/JavaMetadataTest.java =================================================================== --- trunk/sequencers/dna-sequencer-java/src/test/java/org/jboss/dna/sequencer/java/JavaMetadataTest.java 2008-07-25 20:39:42 UTC (rev 371) +++ trunk/sequencers/dna-sequencer-java/src/test/java/org/jboss/dna/sequencer/java/JavaMetadataTest.java 2008-07-26 21:33:14 UTC (rev 372) @@ -163,45 +163,48 @@ // get fields List<FieldMetadata> fields = classMetadata.getFields(); assertNotNull(fields); - assertTrue(fields.size() == 4); + assertTrue(fields.size() == 5); PrimitiveFieldMetadata primitiveFieldMetadata = (PrimitiveFieldMetadata)fields.get(0); assertThat(primitiveFieldMetadata.getCode(), is("int")); assertThat(primitiveFieldMetadata.getVariables().get(0).getName(), is("i")); + assertThat(primitiveFieldMetadata.getVariables().get(1).getName(), is("j")); - ParameterizedFieldMetadata parameterizedFieldMetadata1 = (ParameterizedFieldMetadata)fields.get(1); + ParameterizedFieldMetadata parameterizedFieldMetadata1 = (ParameterizedFieldMetadata)fields.get(2); assertNotNull(parameterizedFieldMetadata1); assertThat(parameterizedFieldMetadata1.getName(), is("List")); assertThat(parameterizedFieldMetadata1.getVariables().get(0).getName(), is("l")); - ParameterizedFieldMetadata parameterizedFieldMetadata2 = (ParameterizedFieldMetadata)fields.get(2); + ParameterizedFieldMetadata parameterizedFieldMetadata2 = (ParameterizedFieldMetadata)fields.get(3); assertNotNull(parameterizedFieldMetadata2); assertThat(parameterizedFieldMetadata2.getName(), is("B")); assertThat(parameterizedFieldMetadata2.getVariables().get(0).getName(), is("o")); - - SimpleFieldMetadata simpleFieldMetadata = (SimpleFieldMetadata)fields.get(3); + + SimpleFieldMetadata simpleFieldMetadata = (SimpleFieldMetadata)fields.get(4); assertNotNull(simpleFieldMetadata); assertThat(simpleFieldMetadata.getName(), is("X")); assertThat(simpleFieldMetadata.getVariables().get(0).getName(), is("x")); - + // get methods List<MethodMetadata> methods = classMetadata.getMethods(); assertNotNull(methods); - assertTrue(methods.size() == 4); - - ConstructorMetadata constructorMetadata = (ConstructorMetadata)methods.get(0); + assertTrue(methods.size() == 5); + + MethodMetadata methodMetadata = methods.get(0); + assertTrue(methodMetadata.isContructor()); + ConstructorMetadata constructorMetadata = (ConstructorMetadata)methodMetadata; assertNotNull(constructorMetadata); assertThat(constructorMetadata.getName(), is("MySource")); - + MethodTypeMemberMetadata methodTypeMemberMetadata1 = (MethodTypeMemberMetadata)methods.get(1); assertNotNull(methodTypeMemberMetadata1); assertThat(methodTypeMemberMetadata1.getName(), is("getI")); - + MethodTypeMemberMetadata methodTypeMemberMetadata2 = (MethodTypeMemberMetadata)methods.get(2); assertNotNull(methodTypeMemberMetadata2); assertThat(methodTypeMemberMetadata2.getName(), is("setI")); - - MethodTypeMemberMetadata methodTypeMemberMetadata3 = (MethodTypeMemberMetadata)methods.get(3); + + MethodTypeMemberMetadata methodTypeMemberMetadata3 = (MethodTypeMemberMetadata)methods.get(4); assertNotNull(methodTypeMemberMetadata3); assertThat(methodTypeMemberMetadata3.getName(), is("doSomething")); } Modified: trunk/sequencers/dna-sequencer-java/src/test/workspace/projectX/src/org/acme/MySource.java =================================================================== --- trunk/sequencers/dna-sequencer-java/src/test/workspace/projectX/src/org/acme/MySource.java 2008-07-25 20:39:42 UTC (rev 371) +++ trunk/sequencers/dna-sequencer-java/src/test/workspace/projectX/src/org/acme/MySource.java 2008-07-26 21:33:14 UTC (rev 372) @@ -29,14 +29,16 @@ */ @MyClassAnnotation public class MySource { - - private int i; + + private int i, j; + private double a; private List<String> l; private A<String>.B<Integer> o; private X x; - - public MySource(){} - + + public MySource() { + } + public int getI() { return this.i; } @@ -44,35 +46,43 @@ public void setI( int i ) { this.i = i; } - + + public void setJ( int j ) { + this.j = j; + } + public void doSomething() { - l= new ArrayList<String>(); + l = new ArrayList<String>(); l.add("N1"); } - + class A<E> { E e; - - A(E e) { + + A( E e ) { this.e = e; } - + @Override public String toString() { return String.valueOf(this.e); } + class B<T> { T t; - B(T t) { + + B( T t ) { this.t = t; } + @Override public String toString() { return String.valueOf(this.t); } } } + class X { - + } }