Author: spagop Date: 2008-09-08 12:25:57 -0400 (Mon, 08 Sep 2008) New Revision: 506 Added: trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/ArrayTypeFieldMetadataSequencer.java trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/VariableSequencer.java Modified: trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/AbstractJavaMetadata.java trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/CompilationUnitParser.java trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/JavaMetadataSequencer.java trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/JavaSourceCndDefinition.java trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/SimpleTypeMetadataSequencer.java trunk/extensions/dna-sequencer-java/src/test/java/org/jboss/dna/sequencer/java/JavaMetadataSequencerTest.java trunk/extensions/dna-sequencer-java/src/test/java/org/jboss/dna/sequencer/java/JavaMetadataTest.java Log: enhancement of sequencer and meta data to support array type Modified: trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/AbstractJavaMetadata.java =================================================================== --- trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/AbstractJavaMetadata.java 2008-09-05 20:01:49 UTC (rev 505) +++ trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/AbstractJavaMetadata.java 2008-09-08 16:25:57 UTC (rev 506) @@ -45,6 +45,7 @@ import org.eclipse.jdt.core.dom.Type; import org.eclipse.jdt.core.dom.TypeDeclaration; import org.eclipse.jdt.core.dom.VariableDeclarationFragment; +import org.jboss.dna.common.util.ArgCheck; import org.jboss.dna.sequencer.java.metadata.ArrayTypeFieldMetadata; import org.jboss.dna.sequencer.java.metadata.ClassMetadata; import org.jboss.dna.sequencer.java.metadata.ConstructorMetadata; @@ -301,57 +302,28 @@ @SuppressWarnings( "unchecked" ) protected void processParametersOfMethodDeclaration( MethodDeclaration methodDeclaration, MethodMetadata methodMetadata ) { - List<SingleVariableDeclaration> params = methodDeclaration.parameters(); - for (SingleVariableDeclaration singleVariableDeclaration : params) { + for (SingleVariableDeclaration singleVariableDeclaration : (List<SingleVariableDeclaration>)methodDeclaration.parameters()) { Type type = singleVariableDeclaration.getType(); if (type.isPrimitiveType()) { - PrimitiveFieldMetadata primitiveFieldMetadata = new PrimitiveFieldMetadata(); - primitiveFieldMetadata.setType(((PrimitiveType)type).getPrimitiveTypeCode().toString()); - Variable variable = new Variable(); - variable.setName(JavaMetadataUtil.getName(singleVariableDeclaration.getName())); - primitiveFieldMetadata.getVariables().add(variable); - List<IExtendedModifier> extendedModifiers = singleVariableDeclaration.modifiers(); - for (IExtendedModifier extendedModifier : extendedModifiers) { - ModifierMetadata modifierMetadata = new ModifierMetadata(); - if (extendedModifier.isAnnotation()) { - // TODO - } else { - Modifier modifier = (Modifier)extendedModifier; - modifierMetadata.setName(modifier.getKeyword().toString()); - primitiveFieldMetadata.getModifiers().add(modifierMetadata); - } - } + PrimitiveFieldMetadata primitiveFieldMetadata = (PrimitiveFieldMetadata)processVariableDeclaration(singleVariableDeclaration, + type); methodMetadata.getParameters().add(primitiveFieldMetadata); } if (type.isParameterizedType()) { - // TODO + ParameterizedTypeFieldMetadata parameterizedTypeFieldMetadata = (ParameterizedTypeFieldMetadata)processVariableDeclaration(singleVariableDeclaration, + type); + methodMetadata.getParameters().add(parameterizedTypeFieldMetadata); } if (type.isQualifiedType()) { // TODO } if (type.isSimpleType()) { - SimpleType simpleType = (SimpleType)type; - SimpleTypeFieldMetadata simpleTypeFieldMetadata = new SimpleTypeFieldMetadata(); - simpleTypeFieldMetadata.setType(JavaMetadataUtil.getName(simpleType.getName())); - Variable variable = new Variable(); - variable.setName(JavaMetadataUtil.getName(singleVariableDeclaration.getName())); - simpleTypeFieldMetadata.getVariables().add(variable); - List<IExtendedModifier> extendedModifiers = singleVariableDeclaration.modifiers(); - for (IExtendedModifier extendedModifier2 : extendedModifiers) { - ModifierMetadata modifierMetadata = new ModifierMetadata(); - if (extendedModifier2.isAnnotation()) { - // TODO - } else { - Modifier modifier = (Modifier)extendedModifier2; - modifierMetadata.setName(modifier.getKeyword().toString()); - simpleTypeFieldMetadata.getModifiers().add(modifierMetadata); - } - } + SimpleTypeFieldMetadata simpleTypeFieldMetadata = (SimpleTypeFieldMetadata)processVariableDeclaration(singleVariableDeclaration, type); methodMetadata.getParameters().add(simpleTypeFieldMetadata); } if (type.isArrayType()) { - - + ArrayTypeFieldMetadata arrayTypeFieldMetadata = (ArrayTypeFieldMetadata)processVariableDeclaration(singleVariableDeclaration, type); + methodMetadata.getParameters().add(arrayTypeFieldMetadata); } if (type.isWildcardType()) { // TODO @@ -361,6 +333,131 @@ } /** + * Process a {@link SingleVariableDeclaration} of a {@link MethodDeclaration}. + * + * @param singleVariableDeclaration + * @param type + * @return a field meta data. + */ + @SuppressWarnings( "unchecked" ) + private FieldMetadata processVariableDeclaration( SingleVariableDeclaration singleVariableDeclaration, + Type type ) { + + Variable variable; + if (type.isPrimitiveType()) { + PrimitiveFieldMetadata primitiveFieldMetadata = new PrimitiveFieldMetadata(); + primitiveFieldMetadata.setType(((PrimitiveType)type).getPrimitiveTypeCode().toString()); + variable = new Variable(); + variable.setName(JavaMetadataUtil.getName(singleVariableDeclaration.getName())); + primitiveFieldMetadata.getVariables().add(variable); + for (IExtendedModifier extendedModifier : (List<IExtendedModifier>)singleVariableDeclaration.modifiers()) { + ModifierMetadata modifierMetadata = new ModifierMetadata(); + if (extendedModifier.isAnnotation()) { + // TODO + } else { + Modifier modifier = (Modifier)extendedModifier; + modifierMetadata.setName(modifier.getKeyword().toString()); + primitiveFieldMetadata.getModifiers().add(modifierMetadata); + } + } + return primitiveFieldMetadata; + } + if(type.isSimpleType()) { + SimpleType simpleType = (SimpleType)type; + SimpleTypeFieldMetadata simpleTypeFieldMetadata = new SimpleTypeFieldMetadata(); + simpleTypeFieldMetadata.setType(JavaMetadataUtil.getName(simpleType.getName())); + variable = new Variable(); + variable.setName(JavaMetadataUtil.getName(singleVariableDeclaration.getName())); + simpleTypeFieldMetadata.getVariables().add(variable); + for (IExtendedModifier simpleTypeExtendedModifier : (List<IExtendedModifier> )singleVariableDeclaration.modifiers()) { + ModifierMetadata modifierMetadata = new ModifierMetadata(); + if (simpleTypeExtendedModifier.isAnnotation()) { + // TODO + } else { + Modifier modifier = (Modifier)simpleTypeExtendedModifier; + modifierMetadata.setName(modifier.getKeyword().toString()); + simpleTypeFieldMetadata.getModifiers().add(modifierMetadata); + } + } + return simpleTypeFieldMetadata; + } + if (type.isParameterizedType()) { + ParameterizedTypeFieldMetadata parameterizedTypeFieldMetadata = new ParameterizedTypeFieldMetadata(); + ParameterizedType parameterizedType = (ParameterizedType)type; + parameterizedTypeFieldMetadata.setType(getTypeName(parameterizedType)); + variable = new Variable(); + variable.setName(JavaMetadataUtil.getName(singleVariableDeclaration.getName())); + parameterizedTypeFieldMetadata.getVariables().add(variable); + for (IExtendedModifier parameterizedExtendedModifier : (List<IExtendedModifier>)singleVariableDeclaration.modifiers()) { + ModifierMetadata modifierMetadata = new ModifierMetadata(); + if(parameterizedExtendedModifier.isAnnotation()) { + // TODO + } else { + Modifier modifier = (Modifier)parameterizedExtendedModifier; + modifierMetadata.setName(modifier.getKeyword().toString()); + parameterizedTypeFieldMetadata.getModifiers().add(modifierMetadata); + } + } + return parameterizedTypeFieldMetadata; + } + if(type.isArrayType()) { + ArrayTypeFieldMetadata arrayTypeFieldMetadata = new ArrayTypeFieldMetadata(); + ArrayType arrayType = (ArrayType)type; + arrayTypeFieldMetadata.setType(getTypeName(arrayType)); + variable = new Variable(); + variable.setName(JavaMetadataUtil.getName(singleVariableDeclaration.getName())); + arrayTypeFieldMetadata.getVariables().add(variable); + + for (IExtendedModifier arrayTypeExtendedModifier : (List<IExtendedModifier>)singleVariableDeclaration.modifiers()) { + ModifierMetadata modifierMetadata = new ModifierMetadata(); + if(arrayTypeExtendedModifier.isAnnotation()) { + // TODO + } else { + Modifier modifier = (Modifier)arrayTypeExtendedModifier; + modifierMetadata.setName(modifier.getKeyword().toString()); + arrayTypeFieldMetadata.getModifiers().add(modifierMetadata); + } + } + return arrayTypeFieldMetadata; + } + return null; + } + + /** + * Extract the type name + * + * @param type - the type to be processed. This can be primitive, simple, parameterized ... + * @return the name of a type. + * @throws IllegalArgumentException if type is null. + */ + private String getTypeName( Type type ) { + ArgCheck.isNotNull(type, "type"); + if (type.isPrimitiveType()) { + PrimitiveType primitiveType = (PrimitiveType)type; + return primitiveType.getPrimitiveTypeCode().toString(); + } + if (type.isSimpleType()) { + SimpleType simpleType = (SimpleType)type; + return JavaMetadataUtil.getName(simpleType.getName()); + } + if(type.isArrayType()) { + ArrayType arrayType = (ArrayType)type; + // the element type is never an array type + Type elementType = arrayType.getElementType(); + if (elementType.isPrimitiveType()) { + return ((PrimitiveType)elementType).getPrimitiveTypeCode().toString(); + + } + // can't be an array type + if (elementType.isSimpleType()) { + return JavaMetadataUtil.getName(((SimpleType)elementType).getName()); + } + + } + return null; + } + + /** * Get {@link ConstructorMetadata} * * @param methodDeclaration @@ -446,7 +543,7 @@ processModifiersAndVariablesOfFieldDeclaration(fieldDeclaration, arrayTypeFieldMetadata); return arrayTypeFieldMetadata; } - + return null; } Added: trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/ArrayTypeFieldMetadataSequencer.java =================================================================== --- trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/ArrayTypeFieldMetadataSequencer.java (rev 0) +++ trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/ArrayTypeFieldMetadataSequencer.java 2008-09-08 16:25:57 UTC (rev 506) @@ -0,0 +1,118 @@ +/* + * JBoss, Home of Professional Open Source. + * Copyright 2008, Red Hat Middleware LLC, and individual contributors + * as indicated by the @author tags. See the copyright.txt file in the + * distribution for a full listing of individual contributors. + * + * This is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this software; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA, or see the FSF site: http://www.fsf.org. + */ +package org.jboss.dna.sequencer.java; + +import java.util.List; +import org.jboss.dna.sequencer.java.metadata.ArrayTypeFieldMetadata; +import org.jboss.dna.sequencer.java.metadata.ModifierMetadata; +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; +import org.jboss.dna.spi.sequencers.SequencerOutput; + +/** + * Sequencer for array types. + * + * @author Serge Pagop + */ +public class ArrayTypeFieldMetadataSequencer implements JavaSourceCndDefinition { + + /** + * Sequence all formal parameters of a method. + * + * @param output - the {@link SequencerOutput}. + * @param nameFactory - the {@link NameFactory}. + * @param pathFactory - the {@link PathFactory}. + * @param arrayTypeFieldMetadata - the meta data of a array type. + * @param methodParamRootPath - Base path of the method declaration. + */ + public static void sequenceMethodFormalParam( SequencerOutput output, + NameFactory nameFactory, + PathFactory pathFactory, + ArrayTypeFieldMetadata arrayTypeFieldMetadata, + String methodParamRootPath ) { + String methodFormalParamRootPath = ArrayTypeFieldMetadataSequencer.createRootPath(methodParamRootPath); + Path methodParamChildNode = pathFactory.create(methodFormalParamRootPath); + output.setProperty(methodParamChildNode, nameFactory.create(JAVA_ARRAY_TYPE_NAME), arrayTypeFieldMetadata.getType()); + Path ArrayTypeVariableChildNode = pathFactory.create(JavaMetadataUtil.createPath(methodFormalParamRootPath + SLASH + + JAVA_ARRAY_TYPE_VARIABLE + SLASH + + JAVA_VARIABLE)); + for (Variable variable : arrayTypeFieldMetadata.getVariables()) { + VariableSequencer.sequenceTheVariable(output, nameFactory, variable, ArrayTypeVariableChildNode); + } + + } + + /** + * the root path. + * + * @param basePath - the base path to use to build a root path. + * @return the root path, that is compose from other base path. + */ + public static String createRootPath( String basePath ) { + return JavaMetadataUtil.createPath(basePath + SLASH + JAVA_TYPE_CHILD_NODE + SLASH + JAVA_ARRAY_TYPE_CHILD_NODE); + } + + /** + * Sequence member data of array type. + * + * @param arrayTypeFieldMetadata + * @param pathFactory + * @param nameFactory + * @param output + * @param path + * @param index + */ + public static void sequenceFieldMemberData( ArrayTypeFieldMetadata arrayTypeFieldMetadata, + PathFactory pathFactory, + NameFactory nameFactory, + SequencerOutput output, + String path, + int index ) { + + // type + Path arryTypeChildNode = pathFactory.create(path); + output.setProperty(arryTypeChildNode, nameFactory.create(JAVA_ARRAY_TYPE_NAME), arrayTypeFieldMetadata.getType()); + // modifiers + List<ModifierMetadata> modifiers = arrayTypeFieldMetadata.getModifiers(); + int arrayModifierIndex = 1; + for (ModifierMetadata modifierMetadata : modifiers) { + String modifierPath = JavaMetadataUtil.createPathWithIndex(path + SLASH + JAVA_ARRAY_TYPE_MODIFIER_CHILD_NODE + SLASH + + JAVA_MODIFIER_DECLARATION_CHILD_NODE, arrayModifierIndex); + Path modifierChildNode = pathFactory.create(modifierPath); + output.setProperty(modifierChildNode, nameFactory.create(JAVA_MODIFIER_NAME), modifierMetadata.getName()); + arrayModifierIndex++; + } + // variables + List<Variable> variables = arrayTypeFieldMetadata.getVariables(); + int arrayVariableIndex = 1; + for (Variable variable : variables) { + String variablePath = JavaMetadataUtil.createPathWithIndex(path + SLASH + JAVA_ARRAY_TYPE_VARIABLE + SLASH + + JAVA_VARIABLE, arrayVariableIndex); + Path primitiveChildNode = pathFactory.create(variablePath); + VariableSequencer.sequenceTheVariable(output, nameFactory, variable, primitiveChildNode); + arrayVariableIndex++; + } + } + +} Modified: trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/CompilationUnitParser.java =================================================================== --- trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/CompilationUnitParser.java 2008-09-05 20:01:49 UTC (rev 505) +++ trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/CompilationUnitParser.java 2008-09-08 16:25:57 UTC (rev 506) @@ -26,7 +26,7 @@ import org.eclipse.jdt.core.dom.ASTParser; /** - * The Parser, tha process the a compilation unit. + * The Parser, that process the a compilation unit. * * @author Serge Pagop */ Modified: trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/JavaMetadataSequencer.java =================================================================== --- trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/JavaMetadataSequencer.java 2008-09-05 20:01:49 UTC (rev 505) +++ trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/JavaMetadataSequencer.java 2008-09-08 16:25:57 UTC (rev 506) @@ -301,11 +301,13 @@ for (TypeMetadata typeMetadata : javaMetadata.getTypeMetadata()) { // class declaration if (typeMetadata instanceof ClassMetadata) { + + String normalClassRootPath = 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; + 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); + Path classChildNode = pathFactory.create(normalClassRootPath); output.setProperty(classChildNode, nameFactory.create(JAVA_NORMAL_CLASS_NAME), classMetadata.getName()); // process modifiers of the class declaration @@ -313,13 +315,8 @@ int modifierIndex = 1; for (ModifierMetadata modifierMetadata : classModifiers) { - Path classModifierChildNode = 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_MODIFIER_CHILD_NODE + SLASH - + JAVA_MODIFIER_DECLARATION_CHILD_NODE + "[" + Path classModifierChildNode = pathFactory.create(normalClassRootPath + SLASH + JAVA_MODIFIER_CHILD_NODE + + SLASH + JAVA_MODIFIER_DECLARATION_CHILD_NODE + "[" + modifierIndex + "]"); output.setProperty(classModifierChildNode, @@ -331,24 +328,16 @@ int primitiveIndex = 1; int simpleIndex = 1; int parameterizedIndex = 1; + int arrayIndex = 1; for (FieldMetadata fieldMetadata : classMetadata.getFields()) { + String fieldMemberDataRootPath = JavaMetadataUtil.createPath(normalClassRootPath + SLASH + + JAVA_FIELD_CHILD_NODE + SLASH + + JAVA_FIELD_TYPE_CHILD_NODE + SLASH + + JAVA_TYPE_CHILD_NODE); if (fieldMetadata instanceof PrimitiveFieldMetadata) { // primitive type PrimitiveFieldMetadata primitiveFieldMetadata = (PrimitiveFieldMetadata)fieldMetadata; - String primitiveFieldRootPath = JavaMetadataUtil.createPathWithIndex(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 + String primitiveFieldRootPath = JavaMetadataUtil.createPathWithIndex(fieldMemberDataRootPath + SLASH + JAVA_PRIMITIVE_TYPE_CHILD_NODE, primitiveIndex); // type @@ -379,7 +368,7 @@ + JAVA_VARIABLE, primitiveVariableIndex); Path primitiveChildNode = pathFactory.create(variablePath); - sequenceTheVariable(output, nameFactory, variable, primitiveChildNode); + VariableSequencer.sequenceTheVariable(output, nameFactory, variable, primitiveChildNode); primitiveVariableIndex++; } primitiveIndex++; @@ -387,8 +376,17 @@ // Array type if (fieldMetadata instanceof ArrayTypeFieldMetadata) { - @SuppressWarnings( "unused" ) ArrayTypeFieldMetadata arrayTypeFieldMetadata = (ArrayTypeFieldMetadata)fieldMetadata; + String arrayTypeRootPath = JavaMetadataUtil.createPathWithIndex(fieldMemberDataRootPath + SLASH + + JAVA_ARRAY_TYPE_CHILD_NODE, + arrayIndex); + ArrayTypeFieldMetadataSequencer.sequenceFieldMemberData(arrayTypeFieldMetadata, + pathFactory, + nameFactory, + output, + arrayTypeRootPath, + arrayIndex); + arrayIndex++; } // Simple type @@ -441,7 +439,7 @@ + JAVA_VARIABLE, simpleTypeVariableIndex); Path primitiveChildNode = pathFactory.create(variablePath); - sequenceTheVariable(output, nameFactory, variable, primitiveChildNode); + VariableSequencer.sequenceTheVariable(output, nameFactory, variable, primitiveChildNode); simpleTypeVariableIndex++; } @@ -484,7 +482,10 @@ Path parameterizedTypeVariableChildNode = ParameterizedTypeFieldMetadataSequencer.getParameterizedTypeFieldVariablePath(pathFactory, parameterizedTypeFieldRootPath, parameterizedTypeVariableIndex); - sequenceTheVariable(output, nameFactory, variable, parameterizedTypeVariableChildNode); + VariableSequencer.sequenceTheVariable(output, + nameFactory, + variable, + parameterizedTypeVariableChildNode); parameterizedTypeVariableIndex++; } @@ -562,16 +563,20 @@ constructPrimitiveFormalParamRootPath); // variables for (Variable variable : primitiveMetadata.getVariables()) { - sequenceTheVariable(output, nameFactory, variable, constructorPrimitiveParamChildNode); + VariableSequencer.sequenceTheVariable(output, + nameFactory, + variable, + constructorPrimitiveParamChildNode); } } // Simple type if (fieldMetadata instanceof SimpleTypeFieldMetadata) { - processMethodFormalParamOfSimpleType(output, - nameFactory, - pathFactory, - fieldMetadata, - constructorParameterRootPath); + SimpleTypeFieldMetadata simpleTypeFieldMetadata = (SimpleTypeFieldMetadata)fieldMetadata; + SimpleTypeMetadataSequencer.sequenceMethodFormalParam(output, + nameFactory, + pathFactory, + simpleTypeFieldMetadata, + constructorParameterRootPath); } // parameterized type @@ -645,7 +650,7 @@ methodPrimitiveFormalParamRootPath); // variables for (Variable variable : primitive.getVariables()) { - sequenceTheVariable(output, nameFactory, variable, methodParamChildNode); + VariableSequencer.sequenceTheVariable(output, nameFactory, variable, methodParamChildNode); } // type Path methodPrimitiveTypeParamChildNode = pathFactory.create(methodPrimitiveFormalParamRootPath); @@ -656,13 +661,23 @@ } if (fieldMetadata instanceof SimpleTypeFieldMetadata) { - processMethodFormalParamOfSimpleType(output, - nameFactory, - pathFactory, - fieldMetadata, - methodParamRootPath); + SimpleTypeFieldMetadata simpleTypeFieldMetadata = (SimpleTypeFieldMetadata)fieldMetadata; + SimpleTypeMetadataSequencer.sequenceMethodFormalParam(output, + nameFactory, + pathFactory, + simpleTypeFieldMetadata, + methodParamRootPath); } + if (fieldMetadata instanceof ArrayTypeFieldMetadata) { + ArrayTypeFieldMetadata arrayTypeFieldMetadata = (ArrayTypeFieldMetadata)fieldMetadata; + ArrayTypeFieldMetadataSequencer.sequenceMethodFormalParam(output, + nameFactory, + pathFactory, + arrayTypeFieldMetadata, + methodParamRootPath); + } + // TODO parameter reference types methodParameterIndex++; @@ -684,6 +699,10 @@ methodReturnPrimitiveType.getType()); } + if(methodReturnType instanceof SimpleTypeFieldMetadata) { + SimpleTypeFieldMetadata simpleTypeFieldMetadata = (SimpleTypeFieldMetadata) methodReturnType; + SimpleTypeMetadataSequencer.sequenceMethodReturnType(output,nameFactory,pathFactory,simpleTypeFieldMetadata,methodRootPath); + } // TODO method return reference type @@ -699,48 +718,4 @@ progressMonitor.done(); } - - /** - * Process formal parameter of type simple type . - * - * @param output - the {@link SequencerOutput}. - * @param nameFactory - The {@link NameFactory}. - * @param pathFactory - the {@link PathFactory}. - * @param fieldMetadata - the meta data. - * @param methodParamRootPath - base path of the parameter. - */ - private void processMethodFormalParamOfSimpleType( SequencerOutput output, - NameFactory nameFactory, - PathFactory pathFactory, - FieldMetadata fieldMetadata, - String methodParamRootPath ) { - SimpleTypeFieldMetadata simpleTypeFieldMetadata = (SimpleTypeFieldMetadata)fieldMetadata; - String methodSimpleTypeFormalParamRootPath = SimpleTypeMetadataSequencer.createRootPath(methodParamRootPath); - SimpleTypeMetadataSequencer.sequenceConstructorSimpleTypeName(simpleTypeFieldMetadata, - methodSimpleTypeFormalParamRootPath, - output, - nameFactory, - pathFactory); - Path constructorSimpleTypeParamChildNode = SimpleTypeMetadataSequencer.createSimpleTypeParamPath(pathFactory, - methodSimpleTypeFormalParamRootPath); - for (Variable variable : simpleTypeFieldMetadata.getVariables()) { - sequenceTheVariable(output, nameFactory, variable, constructorSimpleTypeParamChildNode); - } - } - - /** - * Sequence a variable. - * - * @param output - the {@link SequencerOutput}. - * @param nameFactory - the {@link NameFactory}. - * @param variable - the variable to be added in the tree. - * @param path - the path - */ - private void sequenceTheVariable( SequencerOutput output, - NameFactory nameFactory, - Variable variable, - Path path ) { - output.setProperty(path, nameFactory.create(JAVA_VARIABLE_NAME), variable.getName()); - } - } Modified: trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/JavaSourceCndDefinition.java =================================================================== --- trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/JavaSourceCndDefinition.java 2008-09-05 20:01:49 UTC (rev 505) +++ trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/JavaSourceCndDefinition.java 2008-09-08 16:25:57 UTC (rev 506) @@ -125,5 +125,12 @@ public static final String JAVA_PARAMETERIZED_TYPE_MODIFIER_CHILD_NODE ="java:parameterizedTypeModifier"; public static final String JAVA_PARAMETERIZED_TYPE_NAME ="java:parameterizedTypeName"; public static final String JAVA_PARAMETERIZED_TYPE_VARIABLE ="java:parameterizedTypeVariable"; + + // Array type + public static final String JAVA_ARRAY_TYPE_CHILD_NODE="java:arrayType"; + public static final String JAVA_ARRAY_TYPE_DESCRIPTION ="java:arrayTypeDescription"; + public static final String JAVA_ARRAY_TYPE_MODIFIER_CHILD_NODE ="java:arrayTypeModifier"; + public static final String JAVA_ARRAY_TYPE_NAME ="java:arrayTypeName"; + public static final String JAVA_ARRAY_TYPE_VARIABLE ="java:arrayTypeVariable"; } Modified: trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/SimpleTypeMetadataSequencer.java =================================================================== --- trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/SimpleTypeMetadataSequencer.java 2008-09-05 20:01:49 UTC (rev 505) +++ trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/SimpleTypeMetadataSequencer.java 2008-09-08 16:25:57 UTC (rev 506) @@ -22,6 +22,7 @@ package org.jboss.dna.sequencer.java; import org.jboss.dna.sequencer.java.metadata.SimpleTypeFieldMetadata; +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; @@ -39,6 +40,32 @@ } /** + * @param output + * @param nameFactory + * @param pathFactory + * @param simpleTypeFieldMetadata + * @param methodParamRootPath + */ + public static void sequenceMethodFormalParam( SequencerOutput output, + NameFactory nameFactory, + PathFactory pathFactory, + SimpleTypeFieldMetadata simpleTypeFieldMetadata, + String methodParamRootPath ) { + + String methodSimpleTypeFormalParamRootPath = SimpleTypeMetadataSequencer.createRootPath(methodParamRootPath); + SimpleTypeMetadataSequencer.sequenceConstructorSimpleTypeName(simpleTypeFieldMetadata, + methodSimpleTypeFormalParamRootPath, + output, + nameFactory, + pathFactory); + Path methodSimpleTypeParamChildNode = SimpleTypeMetadataSequencer.createSimpleTypeParamPath(pathFactory, + methodSimpleTypeFormalParamRootPath); + for (Variable variable : simpleTypeFieldMetadata.getVariables()) { + VariableSequencer.sequenceTheVariable(output, nameFactory, variable, methodSimpleTypeParamChildNode); + } + } + + /** * the root path. * * @param basePath - the base path to use to build a root path. @@ -79,8 +106,32 @@ */ public static Path createSimpleTypeParamPath( PathFactory pathFactory, String rootPath ) { - String paramVariablePath = JavaMetadataUtil.createPath(rootPath + SLASH + JAVA_SIMPLE_TYPE_VARIABLE + SLASH + JAVA_VARIABLE); + String paramVariablePath = JavaMetadataUtil.createPath(rootPath + SLASH + JAVA_SIMPLE_TYPE_VARIABLE + SLASH + + JAVA_VARIABLE); return pathFactory.create(paramVariablePath); } + /** + * Sequence the return type of a method. + * + * @param output + * @param nameFactory + * @param pathFactory + * @param simpleTypeFieldMetadata + * @param methodRootPath + */ + public static void sequenceMethodReturnType( SequencerOutput output, + NameFactory nameFactory, + PathFactory pathFactory, + SimpleTypeFieldMetadata simpleTypeFieldMetadata, + String methodRootPath ) { + String methodReturnSimpleTypePath = JavaMetadataUtil.createPath(methodRootPath + SLASH + JAVA_RETURN_TYPE + SLASH + + JAVA_SIMPLE_TYPE_CHILD_NODE); + + Path methodReturnPrimitiveTypeChildNode = pathFactory.create(methodReturnSimpleTypePath); + output.setProperty(methodReturnPrimitiveTypeChildNode, + nameFactory.create(JAVA_SIMPLE_TYPE_NAME), + simpleTypeFieldMetadata.getType()); + } + } Added: trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/VariableSequencer.java =================================================================== --- trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/VariableSequencer.java (rev 0) +++ trunk/extensions/dna-sequencer-java/src/main/java/org/jboss/dna/sequencer/java/VariableSequencer.java 2008-09-08 16:25:57 UTC (rev 506) @@ -0,0 +1,50 @@ +/* + * JBoss, Home of Professional Open Source. + * Copyright 2008, Red Hat Middleware LLC, and individual contributors + * as indicated by the @author tags. See the copyright.txt file in the + * distribution for a full listing of individual contributors. + * + * This is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this software; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA, or see the FSF site: http://www.fsf.org. + */ +package org.jboss.dna.sequencer.java; + +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.sequencers.SequencerOutput; + +/** + * Sequencer for variabels. + * @author Perge Pagop + * + */ +public class VariableSequencer implements JavaSourceCndDefinition { + + /** + * Sequence a variable. + * + * @param output - the {@link SequencerOutput}. + * @param nameFactory - the {@link NameFactory}. + * @param variable - the variable to be added in the tree. + * @param path - the path + */ + public static void sequenceTheVariable( SequencerOutput output, + NameFactory nameFactory, + Variable variable, + Path path ) { + output.setProperty(path, nameFactory.create(JAVA_VARIABLE_NAME), variable.getName()); + } +} Modified: trunk/extensions/dna-sequencer-java/src/test/java/org/jboss/dna/sequencer/java/JavaMetadataSequencerTest.java =================================================================== --- trunk/extensions/dna-sequencer-java/src/test/java/org/jboss/dna/sequencer/java/JavaMetadataSequencerTest.java 2008-09-05 20:01:49 UTC (rev 505) +++ trunk/extensions/dna-sequencer-java/src/test/java/org/jboss/dna/sequencer/java/JavaMetadataSequencerTest.java 2008-09-08 16:25:57 UTC (rev 506) @@ -161,6 +161,27 @@ "java:variableName"), is(new Object[] {"x"})); + assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:field/java:fieldType/java:type/java:arrayType[1]", + "java:arrayTypeName"), + is(new Object[] {"int"})); + assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:field/java:fieldType/java:type/java:arrayType[1]/java:arrayTypeVariable/java:variable[1]", + "java:variableName"), + is(new Object[] {"ia"})); + + assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:field/java:fieldType/java:type/java:arrayType[2]", + "java:arrayTypeName"), + is(new Object[] {"Object"})); + assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:field/java:fieldType/java:type/java:arrayType[2]/java:arrayTypeVariable/java:variable[1]", + "java:variableName"), + is(new Object[] {"oa"})); + + assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:field/java:fieldType/java:type/java:arrayType[3]", + "java:arrayTypeName"), + is(new Object[] {"Collection"})); + assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:field/java:fieldType/java:type/java:arrayType[3]/java:arrayTypeVariable/java:variable[1]", + "java:variableName"), + is(new Object[] {"ca"})); + // support for methods sequencing (modifiers, return type, method name, parameters).Not supported are javadoc // MySource() constructor @@ -256,6 +277,40 @@ "java:variableName"), is(new Object[] {"o"})); + // private double doSomething2(Object[] oa, int[] ia) method + assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[5]/java:modifier/java:modifierDeclaration[1]", + "java:modifierName"), + is(new Object[] {"private"})); + assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[5]/java:resultType/java:primitiveType", + "java:primitiveTypeName"), + is(new Object[] {"double"})); + assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[5]", + "java:methodName"), + is(new Object[] {"doSomething2"})); + assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[5]/java:parameter/java:formalParameter[1]/java:type/java:arrayType", + "java:arrayTypeName"), + is(new Object[] {"Object"})); + assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[5]/java:parameter/java:formalParameter[1]/java:type/java:arrayType/java:arrayTypeVariable/java:variable", + "java:variableName"), + is(new Object[] {"oa"})); + assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[5]/java:parameter/java:formalParameter[2]/java:type/java:arrayType", + "java:arrayTypeName"), + is(new Object[] {"int"})); + assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[5]/java:parameter/java:formalParameter[2]/java:type/java:arrayType/java:arrayTypeVariable/java:variable", + "java:variableName"), + is(new Object[] {"ia"})); + + // public Object doSomething3() method + assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[6]/java:modifier/java:modifierDeclaration[1]", + "java:modifierName"), + is(new Object[] {"public"})); + assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[6]/java:resultType/java:simpleType", + "java:simpleTypeName"), + is(new Object[] {"Object"})); + assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[6]", + "java:methodName"), + is(new Object[] {"doSomething3"})); + } } Modified: trunk/extensions/dna-sequencer-java/src/test/java/org/jboss/dna/sequencer/java/JavaMetadataTest.java =================================================================== --- trunk/extensions/dna-sequencer-java/src/test/java/org/jboss/dna/sequencer/java/JavaMetadataTest.java 2008-09-05 20:01:49 UTC (rev 505) +++ trunk/extensions/dna-sequencer-java/src/test/java/org/jboss/dna/sequencer/java/JavaMetadataTest.java 2008-09-08 16:25:57 UTC (rev 506) @@ -157,7 +157,7 @@ assertThat(marker.getName(), is("MyClassAnnotation")); } } - // get fields + // get fields (member data) List<FieldMetadata> fields = classMetadata.getFields(); assertNotNull(fields); assertTrue(fields.size() > 0); @@ -196,15 +196,15 @@ assertNotNull(arrayTypeFieldMetadata1); assertTrue(arrayTypeFieldMetadata1.getModifiers().size() > 0); assertThat(arrayTypeFieldMetadata1.getType(), is("int")); - assertThat(arrayTypeFieldMetadata1.getVariables().get(0).getName(), is("ai")); + assertThat(arrayTypeFieldMetadata1.getVariables().get(0).getName(), is("ia")); ArrayTypeFieldMetadata arrayTypeFieldMetadata2 = (ArrayTypeFieldMetadata)fields.get(6); assertNotNull(arrayTypeFieldMetadata2); assertTrue(arrayTypeFieldMetadata2.getModifiers().size() > 0); assertThat(arrayTypeFieldMetadata2.getType(), is("Object")); - assertThat(arrayTypeFieldMetadata2.getVariables().get(0).getName(), is("ao")); + assertThat(arrayTypeFieldMetadata2.getVariables().get(0).getName(), is("oa")); - // get methods + // get methods (member functions) List<MethodMetadata> methods = classMetadata.getMethods(); assertNotNull(methods); assertTrue(methods.size() > 0); @@ -250,6 +250,13 @@ assertNotNull(methodTypeMemberMetadata5); assertThat(methodTypeMemberMetadata5.getName(), is("doSomething")); assertTrue(methodTypeMemberMetadata5.getParameters().size() > 0); + + MethodTypeMemberMetadata methodTypeMemberMetadata6 = (MethodTypeMemberMetadata)methods.get(6); + assertTrue(methodTypeMemberMetadata6.getModifiers().size() == 1); + assertEquals(methodTypeMemberMetadata6.getReturnType().getType(), "double"); + assertNotNull(methodTypeMemberMetadata6); + assertThat(methodTypeMemberMetadata6.getName(), is("doSomething2")); + assertTrue(methodTypeMemberMetadata6.getParameters().size() > 0); } } }