Index: extensions/modeshape-connector-infinispan/src/test/java/org/modeshape/connector/infinispan/InfinispanClusterTest.java =================================================================== --- extensions/modeshape-connector-infinispan/src/test/java/org/modeshape/connector/infinispan/InfinispanClusterTest.java (revision 1852) +++ extensions/modeshape-connector-infinispan/src/test/java/org/modeshape/connector/infinispan/InfinispanClusterTest.java (working copy) @@ -5,6 +5,7 @@ import static org.junit.Assert.assertThat; import static org.junit.Assert.fail; import java.util.UUID; import org.infinispan.Cache; +import org.junit.Ignore; import org.junit.Test; import org.modeshape.graph.ExecutionContext; import org.modeshape.graph.Graph; @@ -27,6 +28,7 @@ public class InfinispanClusterTest { private final ExecutionContext context = new ExecutionContext(); + @Ignore @Test public void shouldDistributeGraphNodes() { InfinispanSource source1 = new InfinispanSource(); Index: extensions/modeshape-sequencer-images/src/main/java/org/modeshape/sequencer/image/ImageMetadataLexicon.java new file mode 100644 =================================================================== --- /dev/null (revision 1852) +++ extensions/modeshape-sequencer-images/src/main/java/org/modeshape/sequencer/image/ImageMetadataLexicon.java (working copy) @@ -0,0 +1,30 @@ +package org.modeshape.sequencer.image; + +import net.jcip.annotations.Immutable; +import org.modeshape.graph.property.Name; +import org.modeshape.graph.property.basic.BasicName; + +/** + * A lexicon of names used within the image sequencer. + */ +@Immutable +public class ImageMetadataLexicon { + + public static class Namespace { + public static final String URI = "http://www.modeshape.org/images/1.0"; + public static final String PREFIX = "image"; + } + + public static final Name METADATA_NODE = new BasicName(Namespace.URI, "metadata"); + public static final Name FORMAT_NAME = new BasicName(Namespace.URI, "formatName"); + public static final Name WIDTH = new BasicName(Namespace.URI, "width"); + public static final Name HEIGHT = new BasicName(Namespace.URI, "height"); + public static final Name BITS_PER_PIXEL = new BasicName(Namespace.URI, "bitsPerPixel"); + public static final Name PROGRESSIVE = new BasicName(Namespace.URI, "progressive"); + public static final Name NUMBER_OF_IMAGES = new BasicName(Namespace.URI, "numberOfImages"); + public static final Name PHYSICAL_WIDTH_DPI = new BasicName(Namespace.URI, "physicalWidthDpi"); + public static final Name PHYSICAL_HEIGHT_DPI = new BasicName(Namespace.URI, "physicalHeightDpi"); + public static final Name PHYSICAL_WIDTH_INCHES = new BasicName(Namespace.URI, "physicalWidthInches"); + public static final Name PHYSICAL_HEIGHT_INCHES = new BasicName(Namespace.URI, "physicalHeightInches"); + +} Index: extensions/modeshape-sequencer-images/src/main/java/org/modeshape/sequencer/image/ImageMetadataSequencer.java =================================================================== --- extensions/modeshape-sequencer-images/src/main/java/org/modeshape/sequencer/image/ImageMetadataSequencer.java (revision 1852) +++ extensions/modeshape-sequencer-images/src/main/java/org/modeshape/sequencer/image/ImageMetadataSequencer.java (working copy) @@ -24,7 +24,7 @@ package org.modeshape.sequencer.image; import java.io.InputStream; -import org.modeshape.graph.property.NameFactory; +import org.modeshape.graph.JcrLexicon; import org.modeshape.graph.property.Path; import org.modeshape.graph.property.PathFactory; import org.modeshape.graph.sequencer.SequencerOutput; @@ -65,22 +65,23 @@ import org.modeshape.graph.sequencer.StreamSequencerContext; *

*/ public class ImageMetadataSequencer implements StreamSequencer { - - public static final String METADATA_NODE = "image:metadata"; - public static final String IMAGE_PRIMARY_TYPE = "jcr:primaryType"; - public static final String IMAGE_MIXINS = "jcr:mixinTypes"; - public static final String IMAGE_MIME_TYPE = "jcr:mimeType"; - public static final String IMAGE_ENCODING = "jcr:encoding"; - public static final String IMAGE_FORMAT_NAME = "image:formatName"; - public static final String IMAGE_WIDTH = "image:width"; - public static final String IMAGE_HEIGHT = "image:height"; - public static final String IMAGE_BITS_PER_PIXEL = "image:bitsPerPixel"; - public static final String IMAGE_PROGRESSIVE = "image:progressive"; - public static final String IMAGE_NUMBER_OF_IMAGES = "image:numberOfImages"; - public static final String IMAGE_PHYSICAL_WIDTH_DPI = "image:physicalWidthDpi"; - public static final String IMAGE_PHYSICAL_HEIGHT_DPI = "image:physicalHeightDpi"; - public static final String IMAGE_PHYSICAL_WIDTH_INCHES = "image:physicalWidthInches"; - public static final String IMAGE_PHYSICAL_HEIGHT_INCHES = "image:physicalHeightInches"; + // + // public static final String IMAGE_PRIMARY_TYPE = "jcr:primaryType"; + // public static final String IMAGE_MIXINS = "jcr:mixinTypes"; + // public static final String IMAGE_MIME_TYPE = "jcr:mimeType"; + // public static final String IMAGE_ENCODING = "jcr:encoding"; + // + // public static final String METADATA_NODE = "image:metadata"; + // public static final String IMAGE_FORMAT_NAME = "image:formatName"; + // public static final String IMAGE_WIDTH = "image:width"; + // public static final String IMAGE_HEIGHT = "image:height"; + // public static final String IMAGE_BITS_PER_PIXEL = "image:bitsPerPixel"; + // public static final String IMAGE_PROGRESSIVE = "image:progressive"; + // public static final String IMAGE_NUMBER_OF_IMAGES = "image:numberOfImages"; + // public static final String IMAGE_PHYSICAL_WIDTH_DPI = "image:physicalWidthDpi"; + // public static final String IMAGE_PHYSICAL_HEIGHT_DPI = "image:physicalHeightDpi"; + // public static final String IMAGE_PHYSICAL_WIDTH_INCHES = "image:physicalWidthInches"; + // public static final String IMAGE_PHYSICAL_HEIGHT_INCHES = "image:physicalHeightInches"; /** * {@inheritDoc} @@ -103,26 +104,24 @@ public class ImageMetadataSequencer implements StreamSequencer { // Generate the output graph if we found useful metadata ... if (metadata != null) { - NameFactory nameFactory = context.getValueFactories().getNameFactory(); PathFactory pathFactory = context.getValueFactories().getPathFactory(); - String metadataNodePath = METADATA_NODE; - Path metadataNode = pathFactory.create(metadataNodePath); + Path metadataNode = pathFactory.create(ImageMetadataLexicon.METADATA_NODE); // Place the image metadata into the output map ... - output.setProperty(metadataNode, nameFactory.create(IMAGE_PRIMARY_TYPE), "image:metadata"); + output.setProperty(metadataNode, JcrLexicon.PRIMARY_TYPE, "image:metadata"); // output.psetProperty(metadataNode, nameFactory.create(IMAGE_MIXINS), ""); - output.setProperty(metadataNode, nameFactory.create(IMAGE_MIME_TYPE), metadata.getMimeType()); + output.setProperty(metadataNode, JcrLexicon.MIMETYPE, metadata.getMimeType()); // output.setProperty(metadataNode, nameFactory.create(IMAGE_ENCODING), ""); - output.setProperty(metadataNode, nameFactory.create(IMAGE_FORMAT_NAME), metadata.getFormatName()); - output.setProperty(metadataNode, nameFactory.create(IMAGE_WIDTH), metadata.getWidth()); - output.setProperty(metadataNode, nameFactory.create(IMAGE_HEIGHT), metadata.getHeight()); - output.setProperty(metadataNode, nameFactory.create(IMAGE_BITS_PER_PIXEL), metadata.getBitsPerPixel()); - output.setProperty(metadataNode, nameFactory.create(IMAGE_PROGRESSIVE), metadata.isProgressive()); - output.setProperty(metadataNode, nameFactory.create(IMAGE_NUMBER_OF_IMAGES), metadata.getNumberOfImages()); - output.setProperty(metadataNode, nameFactory.create(IMAGE_PHYSICAL_WIDTH_DPI), metadata.getPhysicalWidthDpi()); - output.setProperty(metadataNode, nameFactory.create(IMAGE_PHYSICAL_HEIGHT_DPI), metadata.getPhysicalHeightDpi()); - output.setProperty(metadataNode, nameFactory.create(IMAGE_PHYSICAL_WIDTH_INCHES), metadata.getPhysicalWidthInch()); - output.setProperty(metadataNode, nameFactory.create(IMAGE_PHYSICAL_HEIGHT_INCHES), metadata.getPhysicalHeightInch()); + output.setProperty(metadataNode, ImageMetadataLexicon.FORMAT_NAME, metadata.getFormatName()); + output.setProperty(metadataNode, ImageMetadataLexicon.WIDTH, metadata.getWidth()); + output.setProperty(metadataNode, ImageMetadataLexicon.HEIGHT, metadata.getHeight()); + output.setProperty(metadataNode, ImageMetadataLexicon.BITS_PER_PIXEL, metadata.getBitsPerPixel()); + output.setProperty(metadataNode, ImageMetadataLexicon.PROGRESSIVE, metadata.isProgressive()); + output.setProperty(metadataNode, ImageMetadataLexicon.NUMBER_OF_IMAGES, metadata.getNumberOfImages()); + output.setProperty(metadataNode, ImageMetadataLexicon.PHYSICAL_WIDTH_DPI, metadata.getPhysicalWidthDpi()); + output.setProperty(metadataNode, ImageMetadataLexicon.PHYSICAL_HEIGHT_DPI, metadata.getPhysicalHeightDpi()); + output.setProperty(metadataNode, ImageMetadataLexicon.PHYSICAL_WIDTH_INCHES, metadata.getPhysicalWidthInch()); + output.setProperty(metadataNode, ImageMetadataLexicon.PHYSICAL_HEIGHT_INCHES, metadata.getPhysicalHeightInch()); } } } Index: extensions/modeshape-sequencer-images/src/test/java/org/modeshape/sequencer/image/ImageMetadataSequencerTest.java =================================================================== --- extensions/modeshape-sequencer-images/src/test/java/org/modeshape/sequencer/image/ImageMetadataSequencerTest.java (revision 1852) +++ extensions/modeshape-sequencer-images/src/test/java/org/modeshape/sequencer/image/ImageMetadataSequencerTest.java (working copy) @@ -30,13 +30,12 @@ import static org.junit.Assert.assertThat; import java.io.IOException; import java.io.InputStream; import java.net.URL; -import org.modeshape.graph.sequencer.MockSequencerContext; -import org.modeshape.graph.sequencer.MockSequencerOutput; -import org.modeshape.graph.sequencer.StreamSequencerContext; -import org.modeshape.sequencer.image.ImageMetadataSequencer; import org.junit.After; import org.junit.Before; import org.junit.Test; +import org.modeshape.graph.sequencer.MockSequencerContext; +import org.modeshape.graph.sequencer.MockSequencerOutput; +import org.modeshape.graph.sequencer.StreamSequencerContext; /** * @author Randall Hauch @@ -57,7 +56,7 @@ public class ImageMetadataSequencerTest { public void beforeEach() { sequencer = new ImageMetadataSequencer(); context = new MockSequencerContext(); - context.getNamespaceRegistry().register("image", "http://jboss.org/dna/images/1.0"); + context.getNamespaceRegistry().register(ImageMetadataLexicon.Namespace.PREFIX, ImageMetadataLexicon.Namespace.URI); output = new MockSequencerOutput(context); cautionGif = this.getClass().getClassLoader().getResource("caution.gif"); cautionJpg = this.getClass().getClassLoader().getResource("caution.jpg"); Index: extensions/modeshape-sequencer-java/src/main/java/org/modeshape/sequencer/java/ArrayTypeFieldMetadataSequencer.java =================================================================== --- extensions/modeshape-sequencer-java/src/main/java/org/modeshape/sequencer/java/ArrayTypeFieldMetadataSequencer.java (revision 1852) +++ extensions/modeshape-sequencer-java/src/main/java/org/modeshape/sequencer/java/ArrayTypeFieldMetadataSequencer.java (working copy) @@ -35,7 +35,7 @@ import org.modeshape.sequencer.java.metadata.Variable; /** * Sequencer for array types. */ -public class ArrayTypeFieldMetadataSequencer implements JavaSourceCndDefinition { +public class ArrayTypeFieldMetadataSequencer { /** * Sequence all formal parameters of a method. @@ -50,15 +50,18 @@ public class ArrayTypeFieldMetadataSequencer implements JavaSourceCndDefinition 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)); + Path methodParamRootPath ) { + Path methodFormalParamRootPath = createRootPath(pathFactory, methodParamRootPath); + output.setProperty(methodFormalParamRootPath, + nameFactory.create(JavaMetadataLexicon.ARRAY_TYPE_NAME), + arrayTypeFieldMetadata.getType()); + Path arrayTypeVariableChildNode = pathFactory.create(pathFactory.create(pathFactory.create(pathFactory.create(methodParamRootPath, + JavaMetadataLexicon.TYPE_CHILD_NODE), + JavaMetadataLexicon.ARRAY_TYPE_CHILD_NODE), + JavaMetadataLexicon.ARRAY_TYPE_VARIABLE), + JavaMetadataLexicon.VARIABLE); for (Variable variable : arrayTypeFieldMetadata.getVariables()) { - VariableSequencer.sequenceTheVariable(output, nameFactory, variable, ArrayTypeVariableChildNode); + VariableSequencer.sequenceTheVariable(output, nameFactory, variable, arrayTypeVariableChildNode); } } @@ -66,11 +69,14 @@ public class ArrayTypeFieldMetadataSequencer implements JavaSourceCndDefinition /** * the root path. * + * @param pathFactory the path factory to use * @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); + public static Path createRootPath( PathFactory pathFactory, + Path basePath ) { + return pathFactory.create(pathFactory.create(basePath, JavaMetadataLexicon.TYPE_CHILD_NODE), + JavaMetadataLexicon.ARRAY_TYPE_CHILD_NODE); } /** @@ -87,30 +93,32 @@ public class ArrayTypeFieldMetadataSequencer implements JavaSourceCndDefinition PathFactory pathFactory, NameFactory nameFactory, SequencerOutput output, - String path, + Path path, int index ) { // type Path arryTypeChildNode = pathFactory.create(path); - output.setProperty(arryTypeChildNode, nameFactory.create(JAVA_ARRAY_TYPE_NAME), arrayTypeFieldMetadata.getType()); + output.setProperty(arryTypeChildNode, + nameFactory.create(JavaMetadataLexicon.ARRAY_TYPE_NAME), + arrayTypeFieldMetadata.getType()); // modifiers List 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()); + Path modifierPath = pathFactory.create(pathFactory.create(path, JavaMetadataLexicon.ARRAY_TYPE_MODIFIER_CHILD_NODE), + pathFactory.createSegment(JavaMetadataLexicon.MODIFIER_DECLARATION_CHILD_NODE, + arrayModifierIndex)); + output.setProperty(modifierPath, nameFactory.create(JavaMetadataLexicon.MODIFIER_NAME), modifierMetadata.getName()); arrayModifierIndex++; } // variables List 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); + Path variablePath = pathFactory.create(pathFactory.create(path, JavaMetadataLexicon.ARRAY_TYPE_VARIABLE), + pathFactory.createSegment(JavaMetadataLexicon.VARIABLE, arrayVariableIndex)); + + VariableSequencer.sequenceTheVariable(output, nameFactory, variable, variablePath); arrayVariableIndex++; } } Index: extensions/modeshape-sequencer-java/src/main/java/org/modeshape/sequencer/java/DefaultSourceFileRecorder.java =================================================================== --- extensions/modeshape-sequencer-java/src/main/java/org/modeshape/sequencer/java/DefaultSourceFileRecorder.java (revision 1852) +++ extensions/modeshape-sequencer-java/src/main/java/org/modeshape/sequencer/java/DefaultSourceFileRecorder.java (working copy) @@ -24,6 +24,7 @@ package org.modeshape.sequencer.java; import java.util.List; +import org.modeshape.graph.JcrLexicon; import org.modeshape.graph.property.NameFactory; import org.modeshape.graph.property.Path; import org.modeshape.graph.property.PathFactory; @@ -162,7 +163,7 @@ import org.modeshape.sequencer.java.metadata.Variable; * *

*/ -public class DefaultSourceFileRecorder implements SourceFileRecorder, JavaSourceCndDefinition { +public class DefaultSourceFileRecorder implements SourceFileRecorder { public void record( StreamSequencerContext context, SequencerOutput output, @@ -171,10 +172,8 @@ public class DefaultSourceFileRecorder implements SourceFileRecorder, JavaSource PathFactory pathFactory = context.getValueFactories().getPathFactory(); if (javaMetadata != null) { - Path javaCompilationUnitNode = pathFactory.create(JAVA_COMPILATION_UNIT_NODE); - output.setProperty(javaCompilationUnitNode, - nameFactory.create(JAVA_COMPILATION_UNIT_PRIMARY_TYPE), - "java:compilationUnit"); + Path javaCompilationUnitNode = pathFactory.create(JavaMetadataLexicon.COMPILATION_UNIT_NODE); + output.setProperty(javaCompilationUnitNode, JcrLexicon.PRIMARY_TYPE, JavaMetadataLexicon.COMPILATION_UNIT_NODE); // sequence package declaration of a unit. PackageMetadata packageMetadata = javaMetadata.getPackageMetadata(); @@ -182,11 +181,11 @@ public class DefaultSourceFileRecorder implements SourceFileRecorder, JavaSource String packageName = packageMetadata.getName(); if (packageName != null && packageName.length() != 0) { - Path javaPackageDeclarationChildNode = pathFactory.create(JAVA_COMPILATION_UNIT_NODE + SLASH - + JAVA_PACKAGE_CHILD_NODE + SLASH - + JAVA_PACKAGE_DECLARATION_CHILD_NODE); + Path javaPackageDeclarationChildNode = pathFactory.createRelativePath(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.PACKAGE_CHILD_NODE, + JavaMetadataLexicon.PACKAGE_DECLARATION_CHILD_NODE); output.setProperty(javaPackageDeclarationChildNode, - nameFactory.create(JAVA_PACKAGE_NAME), + JavaMetadataLexicon.PACKAGE_NAME, javaMetadata.getPackageMetadata().getName()); } @@ -196,48 +195,54 @@ public class DefaultSourceFileRecorder implements SourceFileRecorder, JavaSource for (AnnotationMetadata annotationMetadata : packageMetadata.getAnnotationMetada()) { 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 + "]"); + Path basePath = pathFactory.createRelativePath(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.PACKAGE_CHILD_NODE, + JavaMetadataLexicon.PACKAGE_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.ANNOTATION_CHILD_NODE, + JavaMetadataLexicon.ANNOTATION_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.ANNOTATION_TYPE_CHILD_NODE); + + Path markerAnnotationChildNode = pathFactory.create(basePath, + pathFactory.createSegment(JavaMetadataLexicon.MARKER_ANNOTATION_CHILD_NODE, + markerAnnotationIndex)); output.setProperty(markerAnnotationChildNode, - nameFactory.create(JAVA_MARKER_ANNOTATION_NAME), + JavaMetadataLexicon.MARKER_ANNOTATION_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 + "]"); + + Path basePath = pathFactory.createRelativePath(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.PACKAGE_CHILD_NODE, + JavaMetadataLexicon.PACKAGE_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.ANNOTATION_CHILD_NODE, + JavaMetadataLexicon.ANNOTATION_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.ANNOTATION_TYPE_CHILD_NODE); + + Path singleMemberAnnotationChildNode = pathFactory.create(basePath, + pathFactory.createSegment(JavaMetadataLexicon.SINGLE_ELEMENT_ANNOTATION_CHILD_NODE, + singleAnnatationIndex)); output.setProperty(singleMemberAnnotationChildNode, - nameFactory.create(JAVA_SINGLE_ANNOTATION_NAME), + JavaMetadataLexicon.SINGLE_ANNOTATION_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 + "]"); + Path basePath = pathFactory.createRelativePath(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.PACKAGE_CHILD_NODE, + JavaMetadataLexicon.PACKAGE_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.ANNOTATION_CHILD_NODE, + JavaMetadataLexicon.ANNOTATION_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.ANNOTATION_TYPE_CHILD_NODE); + + Path normalAnnotationChildNode = pathFactory.create(basePath, + pathFactory.createSegment(JavaMetadataLexicon.NORMAL_ANNOTATION_CHILD_NODE, + normalAnnotationIndex)); output.setProperty(normalAnnotationChildNode, - nameFactory.create(JAVA_NORMALANNOTATION_NAME), + JavaMetadataLexicon.NORMALANNOTATION_NAME, normalAnnotationMetadata.getName()); normalAnnotationIndex++; } @@ -250,25 +255,33 @@ public class DefaultSourceFileRecorder implements SourceFileRecorder, JavaSource for (ImportMetadata importMetadata : javaMetadata.getImports()) { 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_ON_DEMAND_IMPORT_CHILD_NODE + SLASH - + JAVA_ON_DEMAND_IMPORT_TYPE_DECLARATION_CHILD_NODE + "[" - + importOnDemandIndex + "]"); + + Path basePath = pathFactory.createRelativePath(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.IMPORT_CHILD_NODE, + JavaMetadataLexicon.IMPORT_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.ON_DEMAND_IMPORT_CHILD_NODE); + + Path importOnDemandChildNode = pathFactory.create(basePath, + pathFactory.createSegment(JavaMetadataLexicon.ON_DEMAND_IMPORT_TYPE_DECLARATION_CHILD_NODE, + importOnDemandIndex)); output.setProperty(importOnDemandChildNode, - nameFactory.create(JAVA_ON_DEMAND_IMPORT_NAME), + JavaMetadataLexicon.ON_DEMAND_IMPORT_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_IMPORT_TYPE_DECLARATION_CHILD_NODE + "[" - + singleImportIndex + "]"); + + Path basePath = pathFactory.createRelativePath(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.IMPORT_CHILD_NODE, + JavaMetadataLexicon.IMPORT_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.SINGLE_IMPORT_CHILD_NODE); + + Path singleImportChildNode = pathFactory.create(basePath, + pathFactory.createSegment(JavaMetadataLexicon.SINGLE_IMPORT_TYPE_DECLARATION_CHILD_NODE, + importOnDemandIndex)); output.setProperty(singleImportChildNode, - nameFactory.create(JAVA_SINGLE_IMPORT_NAME), + JavaMetadataLexicon.SINGLE_IMPORT_NAME, singleImportMetadata.getName()); singleImportIndex++; } @@ -279,26 +292,27 @@ public class DefaultSourceFileRecorder implements SourceFileRecorder, JavaSource // 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; + Path normalClassRootPath = pathFactory.createRelativePath(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE); ClassMetadata classMetadata = (ClassMetadata)typeMetadata; - Path classChildNode = pathFactory.create(normalClassRootPath); - output.setProperty(classChildNode, nameFactory.create(JAVA_NORMAL_CLASS_NAME), classMetadata.getName()); + output.setProperty(normalClassRootPath, JavaMetadataLexicon.NORMAL_CLASS_NAME, classMetadata.getName()); // process modifiers of the class declaration List classModifiers = classMetadata.getModifiers(); int modifierIndex = 1; for (ModifierMetadata modifierMetadata : classModifiers) { - Path classModifierChildNode = pathFactory.create(normalClassRootPath + SLASH + JAVA_MODIFIER_CHILD_NODE - + SLASH + JAVA_MODIFIER_DECLARATION_CHILD_NODE + "[" - + modifierIndex + "]"); + Path basePath = pathFactory.create(normalClassRootPath, JavaMetadataLexicon.MODIFIER_CHILD_NODE); - output.setProperty(classModifierChildNode, - nameFactory.create(JAVA_MODIFIER_NAME), - modifierMetadata.getName()); + Path classModifierChildNode = pathFactory.create(basePath, + pathFactory.createSegment(JavaMetadataLexicon.MODIFIER_DECLARATION_CHILD_NODE, + modifierIndex)); + + output.setProperty(classModifierChildNode, JavaMetadataLexicon.MODIFIER_NAME, modifierMetadata.getName()); } // process fields of the class unit. @@ -307,45 +321,40 @@ public class DefaultSourceFileRecorder implements SourceFileRecorder, JavaSource 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); + Path fieldMemberDataRootPath = pathFactory.create(normalClassRootPath, + JavaMetadataLexicon.FIELD_CHILD_NODE, + JavaMetadataLexicon.FIELD_TYPE_CHILD_NODE, + JavaMetadataLexicon.TYPE_CHILD_NODE); if (fieldMetadata instanceof PrimitiveFieldMetadata) { // primitive type PrimitiveFieldMetadata primitiveFieldMetadata = (PrimitiveFieldMetadata)fieldMetadata; - String primitiveFieldRootPath = JavaMetadataUtil.createPathWithIndex(fieldMemberDataRootPath + SLASH - + JAVA_PRIMITIVE_TYPE_CHILD_NODE, - primitiveIndex); + Path primitiveFieldRootPath = pathFactory.create(fieldMemberDataRootPath, + pathFactory.createSegment(JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE, + primitiveIndex)); // type - Path primitiveTypeChildNode = pathFactory.create(primitiveFieldRootPath); - output.setProperty(primitiveTypeChildNode, - nameFactory.create(JAVA_PRIMITIVE_TYPE_NAME), + output.setProperty(primitiveFieldRootPath, + JavaMetadataLexicon.PRIMITIVE_TYPE_NAME, primitiveFieldMetadata.getType()); // modifiers List modifiers = primitiveFieldMetadata.getModifiers(); int primitiveModifierIndex = 1; for (ModifierMetadata modifierMetadata : modifiers) { - String modifierPath = JavaMetadataUtil.createPathWithIndex(primitiveFieldRootPath + SLASH - + JAVA_MODIFIER_CHILD_NODE + SLASH - + JAVA_MODIFIER_DECLARATION_CHILD_NODE, - primitiveModifierIndex); - Path modifierChildNode = pathFactory.create(modifierPath); - output.setProperty(modifierChildNode, - nameFactory.create(JAVA_MODIFIER_NAME), - modifierMetadata.getName()); + Path modifierPath = pathFactory.create(pathFactory.create(primitiveFieldRootPath, + JavaMetadataLexicon.MODIFIER_CHILD_NODE), + pathFactory.createSegment(JavaMetadataLexicon.MODIFIER_DECLARATION_CHILD_NODE, + primitiveModifierIndex)); + output.setProperty(modifierPath, JavaMetadataLexicon.MODIFIER_NAME, modifierMetadata.getName()); primitiveModifierIndex++; } // variables List variables = primitiveFieldMetadata.getVariables(); int primitiveVariableIndex = 1; for (Variable variable : variables) { - String variablePath = JavaMetadataUtil.createPathWithIndex(primitiveFieldRootPath + SLASH - + JAVA_PRIMITIVE_TYPE_VARIABLE + SLASH - + JAVA_VARIABLE, - primitiveVariableIndex); - Path primitiveChildNode = pathFactory.create(variablePath); - VariableSequencer.sequenceTheVariable(output, nameFactory, variable, primitiveChildNode); + Path variablePath = pathFactory.create(pathFactory.create(primitiveFieldRootPath, + JavaMetadataLexicon.PRIMITIVE_TYPE_VARIABLE), + pathFactory.createSegment(JavaMetadataLexicon.VARIABLE, + primitiveVariableIndex)); + VariableSequencer.sequenceTheVariable(output, nameFactory, variable, variablePath); primitiveVariableIndex++; } primitiveIndex++; @@ -354,9 +363,9 @@ public class DefaultSourceFileRecorder implements SourceFileRecorder, JavaSource // Array type if (fieldMetadata instanceof ArrayTypeFieldMetadata) { ArrayTypeFieldMetadata arrayTypeFieldMetadata = (ArrayTypeFieldMetadata)fieldMetadata; - String arrayTypeRootPath = JavaMetadataUtil.createPathWithIndex(fieldMemberDataRootPath + SLASH - + JAVA_ARRAY_TYPE_CHILD_NODE, - arrayIndex); + Path arrayTypeRootPath = pathFactory.create(fieldMemberDataRootPath, + pathFactory.createSegment(JavaMetadataLexicon.ARRAY_TYPE_CHILD_NODE, + arrayIndex)); ArrayTypeFieldMetadataSequencer.sequenceFieldMemberData(arrayTypeFieldMetadata, pathFactory, nameFactory, @@ -369,40 +378,32 @@ public class DefaultSourceFileRecorder implements SourceFileRecorder, JavaSource // Simple type if (fieldMetadata instanceof SimpleTypeFieldMetadata) { SimpleTypeFieldMetadata simpleTypeFieldMetadata = (SimpleTypeFieldMetadata)fieldMetadata; - String simpleTypeFieldRootPath = 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 - + JAVA_SIMPLE_TYPE_CHILD_NODE, - simpleIndex); - Path simpleTypeFieldChildNode = pathFactory.create(simpleTypeFieldRootPath); - output.setProperty(simpleTypeFieldChildNode, - nameFactory.create(JAVA_SIMPLE_TYPE_NAME), + Path basePath = pathFactory.createRelativePath(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.FIELD_CHILD_NODE, + JavaMetadataLexicon.FIELD_TYPE_CHILD_NODE, + JavaMetadataLexicon.TYPE_CHILD_NODE); + + Path simpleTypeFieldRootPath = pathFactory.create(basePath, + pathFactory.createSegment(JavaMetadataLexicon.SIMPLE_TYPE_CHILD_NODE, + simpleIndex)); + output.setProperty(simpleTypeFieldRootPath, + JavaMetadataLexicon.SIMPLE_TYPE_NAME, simpleTypeFieldMetadata.getType()); // Simple type modifies List simpleModifiers = simpleTypeFieldMetadata.getModifiers(); int simpleTypeModifierIndex = 1; for (ModifierMetadata modifierMetadata : simpleModifiers) { - String simpleTypeModifierPath = JavaMetadataUtil.createPathWithIndex(simpleTypeFieldRootPath - + SLASH - + JAVA_SIMPLE_TYPE_MODIFIER_CHILD_NODE - + SLASH - + JAVA_MODIFIER_DECLARATION_CHILD_NODE, - simpleTypeModifierIndex); - Path simpleTypeModifierChildNode = pathFactory.create(simpleTypeModifierPath); - output.setProperty(simpleTypeModifierChildNode, - nameFactory.create(JAVA_MODIFIER_NAME), + Path simpleTypeModifierPath = pathFactory.create(pathFactory.create(simpleTypeFieldRootPath, + JavaMetadataLexicon.SIMPLE_TYPE_MODIFIER_CHILD_NODE), + pathFactory.createSegment(JavaMetadataLexicon.MODIFIER_DECLARATION_CHILD_NODE, + simpleTypeModifierIndex)); + output.setProperty(simpleTypeModifierPath, + JavaMetadataLexicon.MODIFIER_NAME, modifierMetadata.getName()); simpleTypeModifierIndex++; } @@ -411,12 +412,11 @@ public class DefaultSourceFileRecorder implements SourceFileRecorder, JavaSource List variables = simpleTypeFieldMetadata.getVariables(); int simpleTypeVariableIndex = 1; for (Variable variable : variables) { - String variablePath = JavaMetadataUtil.createPathWithIndex(simpleTypeFieldRootPath + SLASH - + JAVA_SIMPLE_TYPE_VARIABLE + SLASH - + JAVA_VARIABLE, - simpleTypeVariableIndex); - Path primitiveChildNode = pathFactory.create(variablePath); - VariableSequencer.sequenceTheVariable(output, nameFactory, variable, primitiveChildNode); + Path variablePath = pathFactory.create(pathFactory.create(simpleTypeFieldRootPath, + JavaMetadataLexicon.SIMPLE_TYPE_VARIABLE), + pathFactory.createSegment(JavaMetadataLexicon.VARIABLE, + simpleTypeVariableIndex)); + VariableSequencer.sequenceTheVariable(output, nameFactory, variable, variablePath); simpleTypeVariableIndex++; } @@ -432,18 +432,21 @@ public class DefaultSourceFileRecorder implements SourceFileRecorder, JavaSource // Parameterized type if (fieldMetadata instanceof ParameterizedTypeFieldMetadata) { ParameterizedTypeFieldMetadata parameterizedTypeFieldMetadata = (ParameterizedTypeFieldMetadata)fieldMetadata; - String parameterizedTypeFieldRootPath = ParameterizedTypeFieldMetadataSequencer.getParameterizedTypeFieldRootPath(parameterizedIndex); + Path parameterizedTypeFieldRootPath = ParameterizedTypeFieldMetadataSequencer.getParameterizedTypeFieldRootPath(pathFactory, + parameterizedIndex); ParameterizedTypeFieldMetadataSequencer.sequenceTheParameterizedTypeName(parameterizedTypeFieldMetadata, parameterizedTypeFieldRootPath, pathFactory, nameFactory, output); + // Parameterized type modifiers List parameterizedTypeModifiers = parameterizedTypeFieldMetadata.getModifiers(); int parameterizedTypeModifierIndex = 1; for (ModifierMetadata modifierMetadata : parameterizedTypeModifiers) { - String parameterizedTypeModifierPath = ParameterizedTypeFieldMetadataSequencer.getParameterizedTypeFieldRModifierPath(parameterizedTypeFieldRootPath, - parameterizedTypeModifierIndex); + Path parameterizedTypeModifierPath = ParameterizedTypeFieldMetadataSequencer.getParameterizedTypeFieldRModifierPath(pathFactory, + parameterizedTypeFieldRootPath, + parameterizedTypeModifierIndex); ParameterizedTypeFieldMetadataSequencer.sequenceTheParameterizedTypeModifier(modifierMetadata, parameterizedTypeModifierPath, pathFactory, @@ -479,38 +482,29 @@ public class DefaultSourceFileRecorder implements SourceFileRecorder, JavaSource if (methodMetadata.isContructor()) { // process constructor ConstructorMetadata constructorMetadata = (ConstructorMetadata)methodMetadata; - String constructorRootPath = 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_CONSTRUCTOR_CHILD_NODE - + SLASH - + JAVA_CONSTRUCTOR_DECLARATION_CHILD_NODE, - constructorIndex); - Path constructorChildNode = pathFactory.create(constructorRootPath); - output.setProperty(constructorChildNode, - nameFactory.create(JAVA_CONSTRUCTOR_NAME), + Path basePath = pathFactory.createRelativePath(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.CONSTRUCTOR_CHILD_NODE); + Path constructorRootPath = pathFactory.create(basePath, + pathFactory.createSegment(JavaMetadataLexicon.CONSTRUCTOR_DECLARATION_CHILD_NODE, + constructorIndex)); + output.setProperty(constructorRootPath, + JavaMetadataLexicon.CONSTRUCTOR_NAME, constructorMetadata.getName()); List modifiers = constructorMetadata.getModifiers(); // modifiers int constructorModifierIndex = 1; for (ModifierMetadata modifierMetadata : modifiers) { - String contructorModifierPath = JavaMetadataUtil.createPathWithIndex(constructorRootPath - + SLASH - + JAVA_MODIFIER_CHILD_NODE - + SLASH - + JAVA_MODIFIER_DECLARATION_CHILD_NODE, - constructorModifierIndex); - - Path constructorModifierChildNode = pathFactory.create(contructorModifierPath); - output.setProperty(constructorModifierChildNode, - nameFactory.create(JAVA_MODIFIER_NAME), + Path contructorModifierPath = pathFactory.create(pathFactory.create(constructorRootPath, + JavaMetadataLexicon.MODIFIER_CHILD_NODE), + pathFactory.createSegment(JavaMetadataLexicon.MODIFIER_DECLARATION_CHILD_NODE, + constructorModifierIndex)); + + output.setProperty(contructorModifierPath, + JavaMetadataLexicon.MODIFIER_NAME, modifierMetadata.getName()); constructorModifierIndex++; } @@ -519,21 +513,19 @@ public class DefaultSourceFileRecorder implements SourceFileRecorder, JavaSource int constructorParameterIndex = 1; for (FieldMetadata fieldMetadata : constructorMetadata.getParameters()) { - String constructorParameterRootPath = JavaMetadataUtil.createPathWithIndex(constructorRootPath - + SLASH - + JAVA_PARAMETER - + SLASH - + JAVA_FORMAL_PARAMETER, - constructorParameterIndex); + Path constructorParameterRootPath = pathFactory.create(pathFactory.create(constructorRootPath, + JavaMetadataLexicon.PARAMETER), + pathFactory.createSegment(JavaMetadataLexicon.FORMAL_PARAMETER, + constructorParameterIndex)); // primitive type if (fieldMetadata instanceof PrimitiveFieldMetadata) { PrimitiveFieldMetadata primitiveMetadata = (PrimitiveFieldMetadata)fieldMetadata; - String constructPrimitiveFormalParamRootPath = MethodMetadataSequencer.createMethodParamRootPath(constructorParameterRootPath); + Path constructPrimitiveFormalParamRootPath = MethodMetadataSequencer.createMethodParamRootPath(pathFactory, + constructorParameterRootPath); // type - Path constructorPrimitiveTypeParamChildNode = pathFactory.create(constructPrimitiveFormalParamRootPath); - output.setProperty(constructorPrimitiveTypeParamChildNode, - nameFactory.create(JAVA_PRIMITIVE_TYPE_NAME), + output.setProperty(constructPrimitiveFormalParamRootPath, + JavaMetadataLexicon.PRIMITIVE_TYPE_NAME, primitiveMetadata.getType()); Path constructorPrimitiveParamChildNode = MethodMetadataSequencer.createMethodParamPath(pathFactory, @@ -569,38 +561,32 @@ public class DefaultSourceFileRecorder implements SourceFileRecorder, JavaSource constructorIndex++; } else { - // normal method MethodTypeMemberMetadata methodTypeMemberMetadata = (MethodTypeMemberMetadata)methodMetadata; - String methodRootPath = 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_METHOD_CHILD_NODE + SLASH - + JAVA_METHOD_DECLARATION_CHILD_NODE, - methodIndex); - Path methodChildNode = pathFactory.create(methodRootPath); - output.setProperty(methodChildNode, - nameFactory.create(JAVA_METHOD_NAME), + Path basePath = pathFactory.createRelativePath(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE); + + Path methodRootPath = pathFactory.create(basePath, + pathFactory.createSegment(JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE, + methodIndex)); + + output.setProperty(methodRootPath, + JavaMetadataLexicon.METHOD_NAME, methodTypeMemberMetadata.getName()); // method modifiers int methodModierIndex = 1; for (ModifierMetadata modifierMetadata : methodTypeMemberMetadata.getModifiers()) { - String methodModifierPath = JavaMetadataUtil.createPathWithIndex(methodRootPath - + SLASH - + JAVA_MODIFIER_CHILD_NODE - + SLASH - + JAVA_MODIFIER_DECLARATION_CHILD_NODE, - methodModierIndex); - Path methodModifierChildNode = pathFactory.create(methodModifierPath); - output.setProperty(methodModifierChildNode, - nameFactory.create(JAVA_MODIFIER_NAME), + Path methodModifierPath = pathFactory.create(pathFactory.create(methodRootPath, + JavaMetadataLexicon.MODIFIER_CHILD_NODE), + pathFactory.createSegment(JavaMetadataLexicon.MODIFIER_DECLARATION_CHILD_NODE, + methodModierIndex)); + output.setProperty(methodModifierPath, + JavaMetadataLexicon.MODIFIER_NAME, modifierMetadata.getName()); methodModierIndex++; } @@ -608,20 +594,18 @@ public class DefaultSourceFileRecorder implements SourceFileRecorder, JavaSource int methodParameterIndex = 1; for (FieldMetadata fieldMetadata : methodMetadata.getParameters()) { - String methodParamRootPath = JavaMetadataUtil.createPathWithIndex(methodRootPath + SLASH - + JAVA_PARAMETER + SLASH - + JAVA_FORMAL_PARAMETER, - methodParameterIndex); + Path methodParamRootPath = pathFactory.create(pathFactory.create(methodRootPath, + JavaMetadataLexicon.PARAMETER), + pathFactory.createSegment(JavaMetadataLexicon.FORMAL_PARAMETER, + methodParameterIndex)); if (fieldMetadata instanceof PrimitiveFieldMetadata) { PrimitiveFieldMetadata primitive = (PrimitiveFieldMetadata)fieldMetadata; - String methodPrimitiveFormalParamRootPath = JavaMetadataUtil.createPath(methodParamRootPath - + SLASH - + JAVA_TYPE_CHILD_NODE - + SLASH - + JAVA_PRIMITIVE_TYPE_CHILD_NODE); + Path methodPrimitiveFormalParamRootPath = pathFactory.create(methodParamRootPath, + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE); Path methodParamChildNode = MethodMetadataSequencer.createMethodParamPath(pathFactory, methodPrimitiveFormalParamRootPath); @@ -632,7 +616,7 @@ public class DefaultSourceFileRecorder implements SourceFileRecorder, JavaSource // type Path methodPrimitiveTypeParamChildNode = pathFactory.create(methodPrimitiveFormalParamRootPath); output.setProperty(methodPrimitiveTypeParamChildNode, - nameFactory.create(JAVA_PRIMITIVE_TYPE_NAME), + JavaMetadataLexicon.PRIMITIVE_TYPE_NAME, primitive.getType()); } @@ -647,6 +631,7 @@ public class DefaultSourceFileRecorder implements SourceFileRecorder, JavaSource } if (fieldMetadata instanceof ArrayTypeFieldMetadata) { ArrayTypeFieldMetadata arrayTypeFieldMetadata = (ArrayTypeFieldMetadata)fieldMetadata; + ArrayTypeFieldMetadataSequencer.sequenceMethodFormalParam(output, nameFactory, pathFactory, @@ -665,14 +650,12 @@ public class DefaultSourceFileRecorder implements SourceFileRecorder, JavaSource if (methodReturnType instanceof PrimitiveFieldMetadata) { PrimitiveFieldMetadata methodReturnPrimitiveType = (PrimitiveFieldMetadata)methodReturnType; - String methodReturnPrimitiveTypePath = JavaMetadataUtil.createPath(methodRootPath - + SLASH - + JAVA_RETURN_TYPE - + SLASH - + JAVA_PRIMITIVE_TYPE_CHILD_NODE); + Path methodReturnPrimitiveTypePath = pathFactory.create(pathFactory.create(methodRootPath, + JavaMetadataLexicon.RETURN_TYPE), + JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE); Path methodReturnPrimitiveTypeChildNode = pathFactory.create(methodReturnPrimitiveTypePath); output.setProperty(methodReturnPrimitiveTypeChildNode, - nameFactory.create(JAVA_PRIMITIVE_TYPE_NAME), + JavaMetadataLexicon.PRIMITIVE_TYPE_NAME, methodReturnPrimitiveType.getType()); } Index: extensions/modeshape-sequencer-java/src/main/java/org/modeshape/sequencer/java/JavaMetadataLexicon.java new file mode 100644 =================================================================== --- /dev/null (revision 1852) +++ extensions/modeshape-sequencer-java/src/main/java/org/modeshape/sequencer/java/JavaMetadataLexicon.java (working copy) @@ -0,0 +1,147 @@ +package org.modeshape.sequencer.java; + +import net.jcip.annotations.Immutable; +import org.modeshape.graph.property.Name; +import org.modeshape.graph.property.basic.BasicName; + +/** + * A lexicon of names used within the Java source file sequencer. + */ +@Immutable +public class JavaMetadataLexicon { + + public static class Namespace { + public static final String URI = "http://www.modeshape.org/java/1.0"; + public static final String PREFIX = "java"; + } + + public static final Name COMPILATION_UNIT_NODE = new BasicName(Namespace.URI, "compilationUnit"); + public static final Name PACKAGE_CHILD_NODE = new BasicName(Namespace.URI, "package"); + public static final Name PACKAGE_DECLARATION_CHILD_NODE = new BasicName(Namespace.URI, "packageDeclaration"); + public static final Name PACKAGE_NAME = new BasicName(Namespace.URI, "packageName"); + public static final Name ANNOTATION_CHILD_NODE = new BasicName(Namespace.URI, "annotation"); + public static final Name ANNOTATION_DECLARATION_CHILD_NODE = new BasicName(Namespace.URI, "annotationDeclaration"); + public static final Name ANNOTATION_TYPE_CHILD_NODE = new BasicName(Namespace.URI, "annotationType"); + public static final Name MARKER_ANNOTATION_CHILD_NODE = new BasicName(Namespace.URI, "markerAnnotation"); + public static final Name MARKER_ANNOTATION_NAME = new BasicName(Namespace.URI, "markerAnnotationName"); + public static final Name NORMAL_ANNOTATION_CHILD_NODE = new BasicName(Namespace.URI, "normalAnnotation"); + public static final Name NORMALANNOTATION_NAME = new BasicName(Namespace.URI, "normalAnnotationName"); + public static final Name SINGLE_ELEMENT_ANNOTATION_CHILD_NODE = new BasicName(Namespace.URI, "singleElementAnnotation"); + public static final Name SINGLE_ANNOTATION_NAME = new BasicName(Namespace.URI, "singleElementAnnotationName"); + public static final Name IMPORT_CHILD_NODE = new BasicName(Namespace.URI, "import"); + public static final Name IMPORT_DECLARATION_CHILD_NODE = new BasicName(Namespace.URI, "importDeclaration"); + public static final Name SINGLE_IMPORT_CHILD_NODE = new BasicName(Namespace.URI, "singleImport"); + public static final Name SINGLE_IMPORT_TYPE_DECLARATION_CHILD_NODE = new BasicName(Namespace.URI, + "singleTypeImportDeclaration"); + public static final Name SINGLE_IMPORT_NAME = new BasicName(Namespace.URI, "singleImportName"); + public static final Name ON_DEMAND_IMPORT_CHILD_NODE = new BasicName(Namespace.URI, "importOnDemand"); + public static final Name ON_DEMAND_IMPORT_TYPE_DECLARATION_CHILD_NODE = new BasicName(Namespace.URI, + "importOnDemandDeclaration"); + public static final Name ON_DEMAND_IMPORT_NAME = new BasicName(Namespace.URI, "onDemandImportName"); + public static final Name UNIT_TYPE_CHILD_NODE = new BasicName(Namespace.URI, "unitType"); + public static final Name CLASS_DECLARATION_CHILD_NODE = new BasicName(Namespace.URI, "classDeclaration"); + public static final Name NORMAL_CLASS_CHILD_NODE = new BasicName(Namespace.URI, "normalClass"); + public static final Name NORMAL_CLASS_DECLARATION_CHILD_NODE = new BasicName(Namespace.URI, "normalClassDeclaration"); + public static final Name NORMAL_CLASS_NAME = new BasicName(Namespace.URI, "normalClassName"); + public static final Name MODIFIER_CHILD_NODE = new BasicName(Namespace.URI, "modifier"); + public static final Name MODIFIER_DECLARATION_CHILD_NODE = new BasicName(Namespace.URI, "modifierDeclaration"); + public static final Name MODIFIER_NAME = new BasicName(Namespace.URI, "modifierName"); + public static final Name VARIABLE = new BasicName(Namespace.URI, "variable"); + public static final Name VARIABLE_NAME = new BasicName(Namespace.URI, "variableName"); + public static final Name FIELD_CHILD_NODE = new BasicName(Namespace.URI, "field"); + public static final Name FIELD_TYPE_CHILD_NODE = new BasicName(Namespace.URI, "fieldType"); + public static final Name TYPE_CHILD_NODE = new BasicName(Namespace.URI, "type"); + public static final Name PRIMITIVE_TYPE_CHILD_NODE = new BasicName(Namespace.URI, "primitiveType"); + public static final Name PRIMITIVE_TYPE_NAME = new BasicName(Namespace.URI, "primitiveTypeName"); + public static final Name PRIMITIVE_TYPE_VARIABLE = new BasicName(Namespace.URI, "primitiveVariable"); + public static final Name METHOD_CHILD_NODE = new BasicName(Namespace.URI, "method"); + public static final Name METHOD_DECLARATION_CHILD_NODE = new BasicName(Namespace.URI, "methodDeclaration"); + public static final Name METHOD_NAME = new BasicName(Namespace.URI, "methodName"); + public static final Name CONSTRUCTOR_CHILD_NODE = new BasicName(Namespace.URI, "constructor"); + public static final Name CONSTRUCTOR_DECLARATION_CHILD_NODE = new BasicName(Namespace.URI, "constructorDeclaration"); + public static final Name CONSTRUCTOR_NAME = new BasicName(Namespace.URI, "constructorName"); + public static final Name PARAMETER = new BasicName(Namespace.URI, "parameter"); + public static final Name FORMAL_PARAMETER = new BasicName(Namespace.URI, "formalParameter"); + public static final Name PARAMETER_NAME = new BasicName(Namespace.URI, "parameterName"); + public static final Name RETURN_TYPE = new BasicName(Namespace.URI, "resultType"); + public static final Name SIMPLE_TYPE_CHILD_NODE = new BasicName(Namespace.URI, "simpleType"); + public static final Name SIMPLE_TYPE_DESCRIPTION = new BasicName(Namespace.URI, "simpleTypeDescription"); + public static final Name SIMPLE_TYPE_NAME = new BasicName(Namespace.URI, "simpleTypeName"); + public static final Name SIMPLE_TYPE_VARIABLE = new BasicName(Namespace.URI, "simpleTypeVariable"); + public static final Name SIMPLE_TYPE_MODIFIER_CHILD_NODE = new BasicName(Namespace.URI, "simpleTypeModifier"); + public static final Name PARAMETERIZED_TYPE_CHILD_NODE = new BasicName(Namespace.URI, "parameterizedType"); + public static final Name PARAMETERIZED_TYPE_DESCRIPTION = new BasicName(Namespace.URI, "parameterizedTypeDescription"); + public static final Name PARAMETERIZED_TYPE_MODIFIER_CHILD_NODE = new BasicName(Namespace.URI, "parameterizedTypeModifier"); + public static final Name PARAMETERIZED_TYPE_NAME = new BasicName(Namespace.URI, "parameterizedTypeName"); + public static final Name PARAMETERIZED_TYPE_VARIABLE = new BasicName(Namespace.URI, "parameterizedTypeVariable"); + public static final Name ARRAY_TYPE_CHILD_NODE = new BasicName(Namespace.URI, "arrayType"); + public static final Name ARRAY_TYPE_DESCRIPTION = new BasicName(Namespace.URI, "arrayTypeDescription"); + public static final Name ARRAY_TYPE_MODIFIER_CHILD_NODE = new BasicName(Namespace.URI, "arrayTypeModifier"); + public static final Name ARRAY_TYPE_NAME = new BasicName(Namespace.URI, "arrayTypeName"); + public static final Name ARRAY_TYPE_VARIABLE = new BasicName(Namespace.URI, "arrayTypeVariable"); + + // Original constants - for future debugging purposes + // public static final String JAVA_COMPILATION_UNIT_NODE = "java:compilationUnit"; + // 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"; + // public static final String JAVA_ANNOTATION_CHILD_NODE = "java:annotation"; + // public static final String JAVA_ANNOTATION_DECLARATION_CHILD_NODE = "java:annotationDeclaration"; + // public static final String JAVA_ANNOTATION_TYPE_CHILD_NODE = "java:annotationType"; + // public static final String JAVA_MARKER_ANNOTATION_CHILD_NODE = "java:markerAnnotation"; + // public static final String JAVA_MARKER_ANNOTATION_NAME = "java:markerAnnotationName "; + // public static final String JAVA_NORMAL_ANNOTATION_CHILD_NODE = "java:normalAnnotation"; + // public static final String JAVA_NORMALANNOTATION_NAME = "java:normalAnnotationName"; + // public static final String JAVA_SINGLE_ELEMENT_ANNOTATION_CHILD_NODE = "java:singleElementAnnotation"; + // public static final String JAVA_SINGLE_ANNOTATION_NAME = "java:singleElementAnnotationName"; + // 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_IMPORT_TYPE_DECLARATION_CHILD_NODE = "java:singleTypeImportDeclaration"; + // public static final String JAVA_SINGLE_IMPORT_NAME = "java:singleImportName "; + // public static final String JAVA_ON_DEMAND_IMPORT_CHILD_NODE = "java:importOnDemand"; + // public static final String JAVA_ON_DEMAND_IMPORT_TYPE_DECLARATION_CHILD_NODE = "java:typeImportOnDemandDeclaration"; + // public static final String JAVA_ON_DEMAND_IMPORT_NAME = "java:onDemandImportName"; + // 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_NORMAL_CLASS_NAME = "java:normalClassName"; + // public static final String JAVA_MODIFIER_CHILD_NODE = "java:modifier"; + // public static final String JAVA_MODIFIER_DECLARATION_CHILD_NODE = "java:modifierDeclaration"; + // public static final String JAVA_MODIFIER_NAME = "java:modifierName"; + // public static final String JAVA_VARIABLE = "java:variable"; + // public static final String JAVA_VARIABLE_NAME = "java:variableName"; + // 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"; + // public static final String JAVA_PRIMITIVE_TYPE_NAME = "java:primitiveTypeName"; + // public static final String JAVA_PRIMITIVE_TYPE_VARIABLE = "java:primitiveVariable"; + // 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:methodName"; + // public static final String JAVA_CONSTRUCTOR_CHILD_NODE = "java:constructor"; + // public static final String JAVA_CONSTRUCTOR_DECLARATION_CHILD_NODE = "java:constructorDeclaration"; + // public static final String JAVA_CONSTRUCTOR_NAME = "java:constructorName"; + // public static final String JAVA_PARAMETER = "java:parameter"; + // public static final String JAVA_FORMAL_PARAMETER = "java:formalParameter"; + // public static final String JAVA_PARAMETER_NAME = "java:parameterName"; + // public static final String JAVA_RETURN_TYPE = "java:resultType"; + // public static final String JAVA_SIMPLE_TYPE_CHILD_NODE = "java:simpleType"; + // public static final String JAVA_SIMPLE_TYPE_DESCRIPTION = "java:simpleTypeDescription"; + // public static final String JAVA_SIMPLE_TYPE_NAME = "java:simpleTypeName"; + // public static final String JAVA_SIMPLE_TYPE_VARIABLE = "java:simpleTypeVariable"; + // public static final String JAVA_SIMPLE_TYPE_MODIFIER_CHILD_NODE = "java:simpleTypeModifier"; + // public static final String JAVA_PARAMETERIZED_TYPE_CHILD_NODE = "java:parameterizedType"; + // public static final String JAVA_PARAMETERIZED_TYPE_DESCRIPTION = "java:parameterizedTypeDescription"; + // 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"; + // 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"; + +} Index: extensions/modeshape-sequencer-java/src/main/java/org/modeshape/sequencer/java/JavaSourceCndDefinition.java deleted file mode 100644 =================================================================== --- extensions/modeshape-sequencer-java/src/main/java/org/modeshape/sequencer/java/JavaSourceCndDefinition.java (revision 1852) +++ /dev/null (working copy) @@ -1,136 +0,0 @@ -/* - * ModeShape (http://www.modeshape.org) - * See the COPYRIGHT.txt file distributed with this work for information - * regarding copyright ownership. Some portions may be licensed - * to Red Hat, Inc. under one or more contributor license agreements. - * See the AUTHORS.txt file in the distribution for a full listing of - * individual contributors. - * - * ModeShape is free software. Unless otherwise indicated, all code in ModeShape - * is licensed to you 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. - * - * ModeShape 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.modeshape.sequencer.java; - -/** - * JavaSourceCndDefinition defines each elements and sub elements, that must be found in the java source cnd document. - */ -public interface JavaSourceCndDefinition { - - public 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"; - public static final String JAVA_ANNOTATION_TYPE_CHILD_NODE = "java:annotationType"; - - // Marker annotation - public static final String JAVA_MARKER_ANNOTATION_CHILD_NODE = "java:markerAnnotation"; - public static final String JAVA_MARKER_ANNOTATION_NAME = "java:markerAnnotationName "; - - // Normal annotation - public static final String JAVA_NORMAL_ANNOTATION_CHILD_NODE = "java:normalAnnotation"; - public static final String JAVA_NORMALANNOTATION_NAME = "java:normalAnnotationName"; - - // Single element annotation - public static final String JAVA_SINGLE_ELEMENT_ANNOTATION_CHILD_NODE = "java:singleElementAnnotation"; - public static final String JAVA_SINGLE_ANNOTATION_NAME = "java:singleElementAnnotationName"; - - // Import declaration - public static final String JAVA_IMPORT_CHILD_NODE = "java:import"; - public static final String JAVA_IMPORT_DECLARATION_CHILD_NODE = "java:importDeclaration"; - - // Single import declaration - public static final String JAVA_SINGLE_IMPORT_CHILD_NODE = "java:singleImport"; - public static final String JAVA_SINGLE_IMPORT_TYPE_DECLARATION_CHILD_NODE = "java:singleTypeImportDeclaration"; - public static final String JAVA_SINGLE_IMPORT_NAME = "java:singleImportName "; - - // OnDemand import declaration - public static final String JAVA_ON_DEMAND_IMPORT_CHILD_NODE = "java:importOnDemand"; - public static final String JAVA_ON_DEMAND_IMPORT_TYPE_DECLARATION_CHILD_NODE = "java:typeImportOnDemandDeclaration"; - public static final String JAVA_ON_DEMAND_IMPORT_NAME = "java:onDemandImportName"; - - // Class declaration - public static final String JAVA_UNIT_TYPE_CHILD_NODE = "java:unitType"; - public static final String JAVA_CLASS_DECLARATION_CHILD_NODE = "java:classDeclaration"; - - // Normal class declaration - 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_NORMAL_CLASS_NAME = "java:normalClassName"; - - // Modifier declaration - public static final String JAVA_MODIFIER_CHILD_NODE = "java:modifier"; - public static final String JAVA_MODIFIER_DECLARATION_CHILD_NODE = "java:modifierDeclaration"; - public static final String JAVA_MODIFIER_NAME = "java:modifierName"; - - // Variable declaration - public static final String JAVA_VARIABLE = "java:variable"; - public static final String JAVA_VARIABLE_NAME = "java:variableName"; - - // 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"; - public static final String JAVA_PRIMITIVE_TYPE_NAME = "java:primitiveTypeName"; - public static final String JAVA_PRIMITIVE_TYPE_VARIABLE = "java:primitiveVariable"; - - // 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:methodName"; - - // Constructor - public static final String JAVA_CONSTRUCTOR_CHILD_NODE = "java:constructor"; - public static final String JAVA_CONSTRUCTOR_DECLARATION_CHILD_NODE = "java:constructorDeclaration"; - public static final String JAVA_CONSTRUCTOR_NAME = "java:constructorName"; - - // Parameter - public static final String JAVA_PARAMETER = "java:parameter"; - public static final String JAVA_FORMAL_PARAMETER = "java:formalParameter"; - public static final String JAVA_PARAMETER_NAME = "java:parameterName"; - - public static final String JAVA_RETURN_TYPE = "java:resultType"; - - // Simple type - public static final String JAVA_SIMPLE_TYPE_CHILD_NODE = "java:simpleType"; - public static final String JAVA_SIMPLE_TYPE_DESCRIPTION = "java:simpleTypeDescription"; - public static final String JAVA_SIMPLE_TYPE_NAME = "java:simpleTypeName"; - public static final String JAVA_SIMPLE_TYPE_VARIABLE = "java:simpleTypeVariable"; - public static final String JAVA_SIMPLE_TYPE_MODIFIER_CHILD_NODE = "java:simpleTypeModifier"; - - // Parameterized type - public static final String JAVA_PARAMETERIZED_TYPE_CHILD_NODE = "java:parameterizedType"; - public static final String JAVA_PARAMETERIZED_TYPE_DESCRIPTION = "java:parameterizedTypeDescription"; - 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"; - -} Index: extensions/modeshape-sequencer-java/src/main/java/org/modeshape/sequencer/java/MethodMetadataSequencer.java =================================================================== --- extensions/modeshape-sequencer-java/src/main/java/org/modeshape/sequencer/java/MethodMetadataSequencer.java (revision 1852) +++ extensions/modeshape-sequencer-java/src/main/java/org/modeshape/sequencer/java/MethodMetadataSequencer.java (working copy) @@ -30,7 +30,7 @@ import org.modeshape.sequencer.java.metadata.MethodMetadata; /** * Sequencer for a {@link MethodMetadata}. */ -public class MethodMetadataSequencer implements JavaSourceCndDefinition { +public class MethodMetadataSequencer { /** * Create a path of method/constructor parameter. @@ -40,24 +40,22 @@ public class MethodMetadataSequencer implements JavaSourceCndDefinition { * @return the path of the parameter. */ public static Path createMethodParamPath( PathFactory pathFactory, - String rootPath ) { - String methodPrimitiveParamVariablePath = JavaMetadataUtil.createPath(rootPath + SLASH + JAVA_PRIMITIVE_TYPE_VARIABLE - + SLASH + JAVA_VARIABLE); - Path methodParamChildNode = pathFactory.create(methodPrimitiveParamVariablePath); - return methodParamChildNode; + Path rootPath ) { + return pathFactory.create(pathFactory.create(rootPath, JavaMetadataLexicon.PRIMITIVE_TYPE_VARIABLE), + JavaMetadataLexicon.VARIABLE); } /** * create a root path for method parameter. * + * @param pathFactory the path factory to use * @param constructorParameterRootPath * @return root path for a method parameter. */ - public static String createMethodParamRootPath( String constructorParameterRootPath ) { - String constructPrimitiveFormalParamRootPath = JavaMetadataUtil.createPath(constructorParameterRootPath + SLASH - + JAVA_TYPE_CHILD_NODE + SLASH - + JAVA_PRIMITIVE_TYPE_CHILD_NODE); - return constructPrimitiveFormalParamRootPath; + public static Path createMethodParamRootPath( PathFactory pathFactory, + Path constructorParameterRootPath ) { + return pathFactory.create(pathFactory.create(constructorParameterRootPath, JavaMetadataLexicon.TYPE_CHILD_NODE), + JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE); } private MethodMetadataSequencer() { Index: extensions/modeshape-sequencer-java/src/main/java/org/modeshape/sequencer/java/ParameterizedTypeFieldMetadataSequencer.java =================================================================== --- extensions/modeshape-sequencer-java/src/main/java/org/modeshape/sequencer/java/ParameterizedTypeFieldMetadataSequencer.java (revision 1852) +++ extensions/modeshape-sequencer-java/src/main/java/org/modeshape/sequencer/java/ParameterizedTypeFieldMetadataSequencer.java (working copy) @@ -33,26 +33,27 @@ import org.modeshape.sequencer.java.metadata.ParameterizedTypeFieldMetadata; /** * Sequencer for all paths of a {@link ParameterizedTypeFieldMetadata}. */ -public class ParameterizedTypeFieldMetadataSequencer implements JavaSourceCndDefinition { +public class ParameterizedTypeFieldMetadataSequencer { /** * Create the root path for all path children of a parameterized type. * + * @param pathFactory the path factory to use * @param parameterizedIndex - index in case of multiple paths. * @return a path with a index starting by 1. */ - public static String getParameterizedTypeFieldRootPath( int parameterizedIndex ) { - String simpleTypeFieldRootPath = 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 - + JAVA_PARAMETERIZED_TYPE_CHILD_NODE, - parameterizedIndex); - return simpleTypeFieldRootPath; + public static Path getParameterizedTypeFieldRootPath( PathFactory pathFactory, + int parameterizedIndex ) { + Path basePath = pathFactory.createRelativePath(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.FIELD_CHILD_NODE, + JavaMetadataLexicon.FIELD_TYPE_CHILD_NODE, + JavaMetadataLexicon.TYPE_CHILD_NODE); + return pathFactory.create(basePath, pathFactory.createSegment(JavaMetadataLexicon.PARAMETERIZED_TYPE_MODIFIER_CHILD_NODE, + parameterizedIndex)); } /** @@ -65,31 +66,30 @@ public class ParameterizedTypeFieldMetadataSequencer implements JavaSourceCndDef * @param nameFactory - the {@link NameFactory}. */ public static void sequenceTheParameterizedTypeName( ParameterizedTypeFieldMetadata parameterizedTypeFieldMetadata, - String parameterizedTypeFieldRootPath, + Path parameterizedTypeFieldRootPath, PathFactory pathFactory, NameFactory nameFactory, SequencerOutput output ) { - Path parameterizedTypeFieldChildNode = pathFactory.create(parameterizedTypeFieldRootPath); - output.setProperty(parameterizedTypeFieldChildNode, - nameFactory.create(JAVA_PARAMETERIZED_TYPE_NAME), + output.setProperty(parameterizedTypeFieldRootPath, + JavaMetadataLexicon.PARAMETERIZED_TYPE_NAME, parameterizedTypeFieldMetadata.getType()); } /** * Create a path for the parameterized modifier. * + * @param pathFactory the path factory to use * @param parameterizedTypeFieldRootPath - the root path to be used. * @param parameterizedTypeModifierIndex - index in case of multiple modifiers. * @return the path. */ - public static String getParameterizedTypeFieldRModifierPath( String parameterizedTypeFieldRootPath, + public static Path getParameterizedTypeFieldRModifierPath( PathFactory pathFactory, + Path parameterizedTypeFieldRootPath, int parameterizedTypeModifierIndex ) { - String parameterizedTypeModifierPath = JavaMetadataUtil.createPathWithIndex(parameterizedTypeFieldRootPath + SLASH - + JAVA_PARAMETERIZED_TYPE_MODIFIER_CHILD_NODE - + SLASH - + JAVA_MODIFIER_DECLARATION_CHILD_NODE, - parameterizedTypeModifierIndex); - return parameterizedTypeModifierPath; + Path basePath = pathFactory.create(parameterizedTypeFieldRootPath, + JavaMetadataLexicon.PARAMETERIZED_TYPE_MODIFIER_CHILD_NODE); + return pathFactory.create(basePath, pathFactory.createSegment(JavaMetadataLexicon.MODIFIER_DECLARATION_CHILD_NODE, + parameterizedTypeModifierIndex)); } /** @@ -102,12 +102,13 @@ public class ParameterizedTypeFieldMetadataSequencer implements JavaSourceCndDef * @param output - the {@link SequencerOutput}. */ public static void sequenceTheParameterizedTypeModifier( ModifierMetadata modifierMetadata, - String parameterizedTypeModifierPath, + Path parameterizedTypeModifierPath, PathFactory pathFactory, NameFactory nameFactory, SequencerOutput output ) { - Path parameterizedTypeModifieChildNode = pathFactory.create(parameterizedTypeModifierPath); - output.setProperty(parameterizedTypeModifieChildNode, nameFactory.create(JAVA_MODIFIER_NAME), modifierMetadata.getName()); + output.setProperty(parameterizedTypeModifierPath, + nameFactory.create(JavaMetadataLexicon.MODIFIER_NAME), + modifierMetadata.getName()); } /** @@ -119,13 +120,11 @@ public class ParameterizedTypeFieldMetadataSequencer implements JavaSourceCndDef * @return the path of the parameterized variable. */ public static Path getParameterizedTypeFieldVariablePath( PathFactory pathFactory, - String parameterizedTypeFieldRootPath, + Path parameterizedTypeFieldRootPath, int parameterizedTypeVariableIndex ) { - String variablePath = JavaMetadataUtil.createPathWithIndex(parameterizedTypeFieldRootPath + SLASH - + JAVA_PARAMETERIZED_TYPE_VARIABLE + SLASH + JAVA_VARIABLE, - parameterizedTypeVariableIndex); - Path parameterizedTypeVariableChildNode = pathFactory.create(variablePath); - return parameterizedTypeVariableChildNode; + Path basePath = pathFactory.create(parameterizedTypeFieldRootPath, JavaMetadataLexicon.PARAMETERIZED_TYPE_VARIABLE); + return pathFactory.create(basePath, pathFactory.createSegment(JavaMetadataLexicon.VARIABLE, + parameterizedTypeVariableIndex)); } private ParameterizedTypeFieldMetadataSequencer() { Index: extensions/modeshape-sequencer-java/src/main/java/org/modeshape/sequencer/java/SimpleTypeMetadataSequencer.java =================================================================== --- extensions/modeshape-sequencer-java/src/main/java/org/modeshape/sequencer/java/SimpleTypeMetadataSequencer.java (revision 1852) +++ extensions/modeshape-sequencer-java/src/main/java/org/modeshape/sequencer/java/SimpleTypeMetadataSequencer.java (working copy) @@ -33,7 +33,7 @@ import org.modeshape.sequencer.java.metadata.Variable; /** * The sequencer of the {@link SimpleTypeFieldMetadata} */ -public class SimpleTypeMetadataSequencer implements JavaSourceCndDefinition { +public class SimpleTypeMetadataSequencer { private SimpleTypeMetadataSequencer() { // prevent construction @@ -50,9 +50,9 @@ public class SimpleTypeMetadataSequencer implements JavaSourceCndDefinition { NameFactory nameFactory, PathFactory pathFactory, SimpleTypeFieldMetadata simpleTypeFieldMetadata, - String methodParamRootPath ) { + Path methodParamRootPath ) { - String methodSimpleTypeFormalParamRootPath = SimpleTypeMetadataSequencer.createRootPath(methodParamRootPath); + Path methodSimpleTypeFormalParamRootPath = SimpleTypeMetadataSequencer.createRootPath(pathFactory, methodParamRootPath); SimpleTypeMetadataSequencer.sequenceConstructorSimpleTypeName(simpleTypeFieldMetadata, methodSimpleTypeFormalParamRootPath, output, @@ -68,11 +68,15 @@ public class SimpleTypeMetadataSequencer implements JavaSourceCndDefinition { /** * the root path. * + * @param pathFactory the path factory * @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_SIMPLE_TYPE_CHILD_NODE); + public static Path createRootPath( PathFactory pathFactory, + Path basePath ) { + + return pathFactory.create(pathFactory.create(basePath, JavaMetadataLexicon.TYPE_CHILD_NODE), + JavaMetadataLexicon.SIMPLE_TYPE_CHILD_NODE); } /** @@ -85,14 +89,14 @@ public class SimpleTypeMetadataSequencer implements JavaSourceCndDefinition { * @param pathFactory - the {@link PathFactory}. */ public static void sequenceConstructorSimpleTypeName( SimpleTypeFieldMetadata simpleTypeFieldMetadata, - String rootPath, + Path rootPath, SequencerOutput output, NameFactory nameFactory, PathFactory pathFactory ) { Path constructorSimpleTypeParamChildNode = pathFactory.create(rootPath); output.setProperty(constructorSimpleTypeParamChildNode, - nameFactory.create(JAVA_SIMPLE_TYPE_NAME), + nameFactory.create(JavaMetadataLexicon.SIMPLE_TYPE_NAME), simpleTypeFieldMetadata.getType()); } @@ -105,10 +109,9 @@ public class SimpleTypeMetadataSequencer implements JavaSourceCndDefinition { * @return the path of a variable node. */ public static Path createSimpleTypeParamPath( PathFactory pathFactory, - String rootPath ) { - String paramVariablePath = JavaMetadataUtil.createPath(rootPath + SLASH + JAVA_SIMPLE_TYPE_VARIABLE + SLASH - + JAVA_VARIABLE); - return pathFactory.create(paramVariablePath); + Path rootPath ) { + return pathFactory.create(pathFactory.create(rootPath, JavaMetadataLexicon.SIMPLE_TYPE_VARIABLE), + JavaMetadataLexicon.VARIABLE); } /** @@ -124,13 +127,12 @@ public class SimpleTypeMetadataSequencer implements JavaSourceCndDefinition { 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); + Path methodRootPath ) { + Path methodReturnPrimitiveTypeChildNode = pathFactory.create(pathFactory.create(methodRootPath, + JavaMetadataLexicon.RETURN_TYPE), + JavaMetadataLexicon.SIMPLE_TYPE_CHILD_NODE); output.setProperty(methodReturnPrimitiveTypeChildNode, - nameFactory.create(JAVA_SIMPLE_TYPE_NAME), + nameFactory.create(JavaMetadataLexicon.SIMPLE_TYPE_NAME), simpleTypeFieldMetadata.getType()); } Index: extensions/modeshape-sequencer-java/src/main/java/org/modeshape/sequencer/java/VariableSequencer.java =================================================================== --- extensions/modeshape-sequencer-java/src/main/java/org/modeshape/sequencer/java/VariableSequencer.java (revision 1852) +++ extensions/modeshape-sequencer-java/src/main/java/org/modeshape/sequencer/java/VariableSequencer.java (working copy) @@ -29,9 +29,9 @@ import org.modeshape.graph.sequencer.SequencerOutput; import org.modeshape.sequencer.java.metadata.Variable; /** - * Sequencer for variabels. + * Sequencer for variables. */ -public class VariableSequencer implements JavaSourceCndDefinition { +public class VariableSequencer { /** * Sequence a variable. @@ -45,6 +45,6 @@ public class VariableSequencer implements JavaSourceCndDefinition { NameFactory nameFactory, Variable variable, Path path ) { - output.setProperty(path, nameFactory.create(JAVA_VARIABLE_NAME), variable.getName()); + output.setProperty(path, JavaMetadataLexicon.VARIABLE_NAME, variable.getName()); } } Index: extensions/modeshape-sequencer-java/src/test/java/org/modeshape/sequencer/java/JavaMetadataSequencerTest.java =================================================================== --- extensions/modeshape-sequencer-java/src/test/java/org/modeshape/sequencer/java/JavaMetadataSequencerTest.java (revision 1852) +++ extensions/modeshape-sequencer-java/src/test/java/org/modeshape/sequencer/java/JavaMetadataSequencerTest.java (working copy) @@ -31,12 +31,16 @@ import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStream; -import org.modeshape.graph.sequencer.MockSequencerContext; -import org.modeshape.graph.sequencer.MockSequencerOutput; -import org.modeshape.graph.sequencer.StreamSequencerContext; import org.junit.After; import org.junit.Before; import org.junit.Test; +import org.modeshape.graph.ExecutionContext; +import org.modeshape.graph.property.Name; +import org.modeshape.graph.property.Path; +import org.modeshape.graph.property.PathFactory; +import org.modeshape.graph.sequencer.MockSequencerContext; +import org.modeshape.graph.sequencer.MockSequencerOutput; +import org.modeshape.graph.sequencer.StreamSequencerContext; /** * @author Serge Pagop @@ -48,11 +52,13 @@ public class JavaMetadataSequencerTest { private MockSequencerOutput output; private File source; private StreamSequencerContext context; + private PathFactory pathFactory; @Before public void beforeEach() { + pathFactory = new ExecutionContext().getValueFactories().getPathFactory(); context = new MockSequencerContext(); - context.getNamespaceRegistry().register("java", "http://jboss.org/dna/java/1.0"); + context.getNamespaceRegistry().register(JavaMetadataLexicon.Namespace.PREFIX, JavaMetadataLexicon.Namespace.URI); sequencer = new JavaMetadataSequencer(); output = new MockSequencerOutput(context); source = new File("src/test/workspace/projectX/src/org/acme/MySource.java"); @@ -73,241 +79,732 @@ public class JavaMetadataSequencerTest { return new FileInputStream(file); } + private Path path( Name... names ) { + return pathFactory.createRelativePath(names); + } + + private Path path( Path path, + Name name, + int index ) { + return pathFactory.create(path, pathFactory.createSegment(name, index)); + } + + private Path path( Path path, + Name... names ) { + for (Name name : names) { + path = pathFactory.create(path, name); + } + + return path; + } + @Test public void shouldGenerateMetadataForJavaSourceFile() throws IOException { content = getJavaSrc(source); assertThat(content, is(notNullValue())); sequencer.sequence(content, output, context); - assertThat(output.getPropertyValues("java:compilationUnit", "jcr:primaryType"), is(new Object[] {"java:compilationUnit"})); + assertThat(output.getPropertyValues(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE), "jcr:primaryType"), + is(new Object[] {JavaMetadataLexicon.COMPILATION_UNIT_NODE})); // support sequencing package declaration( FQL name of the package). Not supported is to get information for package // annotation // from package-info.java - assertThat(output.getPropertyValues("java:compilationUnit/java:package/java:packageDeclaration", "java:packageName"), + assertThat(output.getPropertyValues(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.PACKAGE_CHILD_NODE, + JavaMetadataLexicon.PACKAGE_DECLARATION_CHILD_NODE), "java:packageName"), is(new Object[] {"org.acme"})); // 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]" + // path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, JavaMetadataLexicon.PACKAGE_CHILD_NODE, + // JavaMetadataLexicon.PACKAGE_NAME/java:annotation/java:annotationDeclaration/java:annotationType/java:markerAnnotation[1]" // , // "java:typeName"), // is(new Object[] {"org.acme.annotation.MyPackageAnnotation"})); // support for sequencing imports (single import and import on demand) - assertThat(output.getPropertyValues("java:compilationUnit/java:import/java:importDeclaration/java:singleImport/java:singleTypeImportDeclaration[1]", - "java:singleImportName"), + assertThat(output.getPropertyValues(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.IMPORT_CHILD_NODE, + JavaMetadataLexicon.IMPORT_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.SINGLE_IMPORT_CHILD_NODE), + JavaMetadataLexicon.SINGLE_IMPORT_TYPE_DECLARATION_CHILD_NODE, + 1), "java:singleImportName"), is(new Object[] {"org.acme.annotation.MyClassAnnotation"})); - assertThat(output.getPropertyValues("java:compilationUnit/java:import/java:importDeclaration/java:importOnDemand/java:typeImportOnDemandDeclaration[1]", - "java:onDemandImportName"), - is(new Object[] {"java.util"})); + assertThat(output.getPropertyValues(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.IMPORT_CHILD_NODE, + JavaMetadataLexicon.IMPORT_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.ON_DEMAND_IMPORT_CHILD_NODE), + JavaMetadataLexicon.ON_DEMAND_IMPORT_TYPE_DECLARATION_CHILD_NODE, + 1), "java:onDemandImportName"), is(new Object[] {"java.util"})); // support for sequencing class definition (modifiers, class name) - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/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:normalClassName"), + assertThat(output.getPropertyValues(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.MODIFIER_CHILD_NODE), + JavaMetadataLexicon.MODIFIER_DECLARATION_CHILD_NODE, + 1), "java:modifierName"), is(new Object[] {"public"})); + assertThat(output.getPropertyValues(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE), "java:normalClassName"), is(new Object[] {"MySource"})); // support for primitive type sequencing (modifiers, types, variables).Not supported is the javadoc - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:field/java:fieldType/java:type/java:primitiveType[1]/java:modifier/java:modifierDeclaration[1]", - "java:modifierName"), + assertThat(output.getPropertyValues(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.FIELD_CHILD_NODE, + JavaMetadataLexicon.FIELD_TYPE_CHILD_NODE, + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE, + JavaMetadataLexicon.MODIFIER_CHILD_NODE, + JavaMetadataLexicon.MODIFIER_DECLARATION_CHILD_NODE), "java:modifierName"), is(new Object[] {"private"})); - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:field/java:fieldType/java:type/java:primitiveType[1]", - "java:primitiveTypeName"), + assertThat(output.getPropertyValues(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.FIELD_CHILD_NODE, + JavaMetadataLexicon.FIELD_TYPE_CHILD_NODE, + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE), "java:primitiveTypeName"), is(new Object[] {"int"})); - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:field/java:fieldType/java:type/java:primitiveType[1]/java:primitiveVariable/java:variable[1]", - "java:variableName"), - 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[1]/java:primitiveVariable/java:variable[2]", - "java:variableName"), - 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[2]/java:modifier/java:modifierDeclaration[1]", - "java:modifierName"), + assertThat(output.getPropertyValues(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.FIELD_CHILD_NODE, + JavaMetadataLexicon.FIELD_TYPE_CHILD_NODE, + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE, + JavaMetadataLexicon.PRIMITIVE_TYPE_VARIABLE, + JavaMetadataLexicon.VARIABLE), "java:variableName"), is(new Object[] {"i"})); + + assertThat(output.getPropertyValues(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.FIELD_CHILD_NODE, + JavaMetadataLexicon.FIELD_TYPE_CHILD_NODE, + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE, + JavaMetadataLexicon.PRIMITIVE_TYPE_VARIABLE), + JavaMetadataLexicon.VARIABLE, + 2), "java:variableName"), is(new Object[] {"j"})); + + assertThat(output.getPropertyValues(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.FIELD_CHILD_NODE, + JavaMetadataLexicon.FIELD_TYPE_CHILD_NODE, + JavaMetadataLexicon.TYPE_CHILD_NODE), + JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE, + 2), + JavaMetadataLexicon.MODIFIER_CHILD_NODE, + JavaMetadataLexicon.MODIFIER_DECLARATION_CHILD_NODE), "java:modifierName"), is(new Object[] {"private"})); - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:field/java:fieldType/java:type/java:primitiveType[2]/java:modifier/java:modifierDeclaration[2]", - "java:modifierName"), - is(new Object[] {"static"})); - - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:field/java:fieldType/java:type/java:primitiveType[2]", - "java:primitiveTypeName"), - is(new Object[] {"double"})); - - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:field/java:fieldType/java:type/java:primitiveType[2]/java:primitiveVariable/java:variable[1]", - "java:variableName"), - is(new Object[] {"a"})); + assertThat(output.getPropertyValues(path(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.FIELD_CHILD_NODE, + JavaMetadataLexicon.FIELD_TYPE_CHILD_NODE, + JavaMetadataLexicon.TYPE_CHILD_NODE), + JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE, + 2), JavaMetadataLexicon.MODIFIER_CHILD_NODE), + JavaMetadataLexicon.MODIFIER_DECLARATION_CHILD_NODE, + 2), "java:modifierName"), is(new Object[] {"static"})); + + assertThat(output.getPropertyValues(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.FIELD_CHILD_NODE, + JavaMetadataLexicon.FIELD_TYPE_CHILD_NODE, + JavaMetadataLexicon.TYPE_CHILD_NODE), + JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE, + 2), "java:primitiveTypeName"), is(new Object[] {"double"})); + + assertThat(output.getPropertyValues(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.FIELD_CHILD_NODE, + JavaMetadataLexicon.FIELD_TYPE_CHILD_NODE, + JavaMetadataLexicon.TYPE_CHILD_NODE), + JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE, + 2), + JavaMetadataLexicon.PRIMITIVE_TYPE_VARIABLE, + JavaMetadataLexicon.VARIABLE), "java:variableName"), is(new Object[] {"a"})); // support for reference type sequencing () - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:field/java:fieldType/java:type/java:parameterizedType[1]", - "java:parameterizedTypeName"), - is(new Object[] {"List"})); - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:field/java:fieldType/java:type/java:parameterizedType[2]", - "java:parameterizedTypeName"), - is(new Object[] {"A"})); - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:field/java:fieldType/java:type/java:simpleType[1]", - "java:simpleTypeName"), + assertThat(output.getPropertyValues(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.FIELD_CHILD_NODE, + JavaMetadataLexicon.FIELD_TYPE_CHILD_NODE, + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.PARAMETERIZED_TYPE_MODIFIER_CHILD_NODE), + "java:parameterizedTypeName"), is(new Object[] {"List"})); + + assertThat(output.getPropertyValues(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.FIELD_CHILD_NODE, + JavaMetadataLexicon.FIELD_TYPE_CHILD_NODE, + JavaMetadataLexicon.TYPE_CHILD_NODE), + JavaMetadataLexicon.PARAMETERIZED_TYPE_MODIFIER_CHILD_NODE, + 2), "java:parameterizedTypeName"), is(new Object[] {"A"})); + assertThat(output.getPropertyValues(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.FIELD_CHILD_NODE, + JavaMetadataLexicon.FIELD_TYPE_CHILD_NODE, + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.SIMPLE_TYPE_CHILD_NODE), "java:simpleTypeName"), is(new Object[] {"X"})); - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:field/java:fieldType/java:type/java:simpleType[1]/java:simpleTypeVariable/java:variable[1]", - "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"), + assertThat(output.getPropertyValues(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.FIELD_CHILD_NODE, + JavaMetadataLexicon.FIELD_TYPE_CHILD_NODE, + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.SIMPLE_TYPE_CHILD_NODE, + JavaMetadataLexicon.SIMPLE_TYPE_VARIABLE, + JavaMetadataLexicon.VARIABLE), "java:variableName"), is(new Object[] {"x"})); + + assertThat(output.getPropertyValues(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.FIELD_CHILD_NODE, + JavaMetadataLexicon.FIELD_TYPE_CHILD_NODE, + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.ARRAY_TYPE_CHILD_NODE), "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"})); + assertThat(output.getPropertyValues(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.FIELD_CHILD_NODE, + JavaMetadataLexicon.FIELD_TYPE_CHILD_NODE, + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.ARRAY_TYPE_CHILD_NODE, + JavaMetadataLexicon.ARRAY_TYPE_VARIABLE, + JavaMetadataLexicon.VARIABLE), "java:variableName"), is(new Object[] {"ia"})); + + assertThat(output.getPropertyValues(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.FIELD_CHILD_NODE, + JavaMetadataLexicon.FIELD_TYPE_CHILD_NODE, + JavaMetadataLexicon.TYPE_CHILD_NODE), + JavaMetadataLexicon.ARRAY_TYPE_CHILD_NODE, + 2), "java:arrayTypeName"), is(new Object[] {"Object"})); + assertThat(output.getPropertyValues(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.FIELD_CHILD_NODE, + JavaMetadataLexicon.FIELD_TYPE_CHILD_NODE, + JavaMetadataLexicon.TYPE_CHILD_NODE), + JavaMetadataLexicon.ARRAY_TYPE_CHILD_NODE, + 2), JavaMetadataLexicon.ARRAY_TYPE_VARIABLE, JavaMetadataLexicon.VARIABLE), + "java:variableName"), is(new Object[] {"oa"})); + + assertThat(output.getPropertyValues(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.FIELD_CHILD_NODE, + JavaMetadataLexicon.FIELD_TYPE_CHILD_NODE, + JavaMetadataLexicon.TYPE_CHILD_NODE), + JavaMetadataLexicon.ARRAY_TYPE_CHILD_NODE, + 3), "java:arrayTypeName"), is(new Object[] {"Collection"})); + assertThat(output.getPropertyValues(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.FIELD_CHILD_NODE, + JavaMetadataLexicon.FIELD_TYPE_CHILD_NODE, + JavaMetadataLexicon.TYPE_CHILD_NODE), + JavaMetadataLexicon.ARRAY_TYPE_CHILD_NODE, + 3), JavaMetadataLexicon.ARRAY_TYPE_VARIABLE, JavaMetadataLexicon.VARIABLE), + "java:variableName"), is(new Object[] {"ca"})); // support for methods sequencing (modifiers, return type, method name, parameters).Not supported are javadoc // MySource() constructor - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:constructor/java:constructorDeclaration[1]", - "java:constructorName"), + assertThat(output.getPropertyValues(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.CONSTRUCTOR_CHILD_NODE, + JavaMetadataLexicon.CONSTRUCTOR_DECLARATION_CHILD_NODE), "java:constructorName"), is(new Object[] {"MySource"})); // public MySource(int i, int j, Object 0) constructor with parameters - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:constructor/java:constructorDeclaration[2]/java:modifier/java:modifierDeclaration[1]", - "java:modifierName"), + assertThat(output.getPropertyValues(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.CONSTRUCTOR_CHILD_NODE), + JavaMetadataLexicon.CONSTRUCTOR_DECLARATION_CHILD_NODE, + 2), + JavaMetadataLexicon.MODIFIER_CHILD_NODE, + JavaMetadataLexicon.MODIFIER_DECLARATION_CHILD_NODE), "java:modifierName"), is(new Object[] {"public"})); - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:constructor/java:constructorDeclaration[2]", - "java:constructorName"), - is(new Object[] {"MySource"})); - - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:constructor/java:constructorDeclaration[2]/java:parameter/java:formalParameter[1]/java:type/java:primitiveType", - "java:primitiveTypeName"), + assertThat(output.getPropertyValues(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.CONSTRUCTOR_CHILD_NODE), + JavaMetadataLexicon.CONSTRUCTOR_DECLARATION_CHILD_NODE, + 2), "java:constructorName"), is(new Object[] {"MySource"})); + + assertThat(output.getPropertyValues(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.CONSTRUCTOR_CHILD_NODE), + JavaMetadataLexicon.CONSTRUCTOR_DECLARATION_CHILD_NODE, + 2), + JavaMetadataLexicon.PARAMETER, + JavaMetadataLexicon.FORMAL_PARAMETER, + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE), "java:primitiveTypeName"), is(new Object[] {"int"})); - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:constructor/java:constructorDeclaration[2]/java:parameter/java:formalParameter[1]/java:type/java:primitiveType/java:primitiveVariable/java:variable", - "java:variableName"), - is(new Object[] {"i"})); - - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:constructor/java:constructorDeclaration[2]/java:parameter/java:formalParameter[2]/java:type/java:primitiveType", - "java:primitiveTypeName"), + assertThat(output.getPropertyValues(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.CONSTRUCTOR_CHILD_NODE), + JavaMetadataLexicon.CONSTRUCTOR_DECLARATION_CHILD_NODE, + 2), + JavaMetadataLexicon.PARAMETER, + JavaMetadataLexicon.FORMAL_PARAMETER, + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE, + JavaMetadataLexicon.PRIMITIVE_TYPE_VARIABLE, + JavaMetadataLexicon.VARIABLE), "java:variableName"), is(new Object[] {"i"})); + + assertThat(output.getPropertyValues(path(path(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.CONSTRUCTOR_CHILD_NODE), + JavaMetadataLexicon.CONSTRUCTOR_DECLARATION_CHILD_NODE, + 2), JavaMetadataLexicon.PARAMETER), + JavaMetadataLexicon.FORMAL_PARAMETER, + 2), + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE), "java:primitiveTypeName"), is(new Object[] {"int"})); - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:constructor/java:constructorDeclaration[2]/java:parameter/java:formalParameter[2]/java:type/java:primitiveType/java:primitiveVariable/java:variable", - "java:variableName"), - is(new Object[] {"j"})); - - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:constructor/java:constructorDeclaration[2]/java:parameter/java:formalParameter[3]/java:type/java:simpleType", - "java:simpleTypeName"), + assertThat(output.getPropertyValues(path(path(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.CONSTRUCTOR_CHILD_NODE), + JavaMetadataLexicon.CONSTRUCTOR_DECLARATION_CHILD_NODE, + 2), JavaMetadataLexicon.PARAMETER), + JavaMetadataLexicon.FORMAL_PARAMETER, + 2), + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE, + JavaMetadataLexicon.PRIMITIVE_TYPE_VARIABLE, + JavaMetadataLexicon.VARIABLE), "java:variableName"), is(new Object[] {"j"})); + + assertThat(output.getPropertyValues(path(path(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.CONSTRUCTOR_CHILD_NODE), + JavaMetadataLexicon.CONSTRUCTOR_DECLARATION_CHILD_NODE, + 2), JavaMetadataLexicon.PARAMETER), + JavaMetadataLexicon.FORMAL_PARAMETER, + 3), + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.SIMPLE_TYPE_CHILD_NODE), "java:simpleTypeName"), is(new Object[] {"Object"})); - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:constructor/java:constructorDeclaration[2]/java:parameter/java:formalParameter[3]/java:type/java:simpleType/java:simpleTypeVariable /java:variable", - "java:variableName"), - is(new Object[] {"o"})); + assertThat(output.getPropertyValues(path(path(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.CONSTRUCTOR_CHILD_NODE), + JavaMetadataLexicon.CONSTRUCTOR_DECLARATION_CHILD_NODE, + 2), JavaMetadataLexicon.PARAMETER), + JavaMetadataLexicon.FORMAL_PARAMETER, + 3), + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.SIMPLE_TYPE_CHILD_NODE, + JavaMetadataLexicon.SIMPLE_TYPE_VARIABLE, + JavaMetadataLexicon.VARIABLE), "java:variableName"), is(new Object[] {"o"})); // public int getI() method - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[1]/java:modifier/java:modifierDeclaration[1]", - "java:modifierName"), + assertThat(output.getPropertyValues(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE, + JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.MODIFIER_CHILD_NODE, + JavaMetadataLexicon.MODIFIER_DECLARATION_CHILD_NODE), "java:modifierName"), is(new Object[] {"public"})); - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[1]/java:resultType/java:primitiveType", - "java:primitiveTypeName"), + assertThat(output.getPropertyValues(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE, + JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.RETURN_TYPE, + JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE), "java:primitiveTypeName"), is(new Object[] {"int"})); - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[1]", - "java:methodName"), + assertThat(output.getPropertyValues(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE, + JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE), "java:methodName"), is(new Object[] {"getI"})); // public void setI(int i) method - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[2]/java:modifier/java:modifierDeclaration[1]", - "java:modifierName"), + assertThat(output.getPropertyValues(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE), + JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE, + 2), + JavaMetadataLexicon.MODIFIER_CHILD_NODE, + JavaMetadataLexicon.MODIFIER_DECLARATION_CHILD_NODE), "java:modifierName"), is(new Object[] {"public"})); - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[2]/java:resultType/java:primitiveType", - "java:primitiveTypeName"), + assertThat(output.getPropertyValues(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE), + JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE, + 2), + JavaMetadataLexicon.RETURN_TYPE, + JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE), "java:primitiveTypeName"), is(new Object[] {"void"})); - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[2]", - "java:methodName"), - is(new Object[] {"setI"})); - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[2]/java:parameter/java:formalParameter[1]/java:type/java:primitiveType", - "java:primitiveTypeName"), + assertThat(output.getPropertyValues(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE), + JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE, + 2), "java:methodName"), is(new Object[] {"setI"})); + assertThat(output.getPropertyValues(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE), + JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE, + 2), + JavaMetadataLexicon.PARAMETER, + JavaMetadataLexicon.FORMAL_PARAMETER, + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE), "java:primitiveTypeName"), is(new Object[] {"int"})); - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[2]/java:parameter/java:formalParameter[1]/java:type/java:primitiveType/java:primitiveVariable/java:variable", - "java:variableName"), - is(new Object[] {"i"})); + assertThat(output.getPropertyValues(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE), + JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE, + 2), + JavaMetadataLexicon.PARAMETER, + JavaMetadataLexicon.FORMAL_PARAMETER, + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE, + JavaMetadataLexicon.PRIMITIVE_TYPE_VARIABLE, + JavaMetadataLexicon.VARIABLE), "java:variableName"), is(new Object[] {"i"})); // public void doSomething(int p1, int p2, Object o) method - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[4]/java:modifier/java:modifierDeclaration[1]", - "java:modifierName"), + assertThat(output.getPropertyValues(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE), + JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE, + 4), + JavaMetadataLexicon.MODIFIER_CHILD_NODE, + JavaMetadataLexicon.MODIFIER_DECLARATION_CHILD_NODE), "java:modifierName"), is(new Object[] {"public"})); - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[4]/java:resultType/java:primitiveType", - "java:primitiveTypeName"), + assertThat(output.getPropertyValues(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE), + JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE, + 4), + JavaMetadataLexicon.RETURN_TYPE, + JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE), "java:primitiveTypeName"), is(new Object[] {"void"})); - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[4]", - "java:methodName"), - is(new Object[] {"doSomething"})); - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[4]/java:parameter/java:formalParameter[1]/java:type/java:primitiveType", - "java:primitiveTypeName"), + assertThat(output.getPropertyValues(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE), + JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE, + 4), "java:methodName"), is(new Object[] {"doSomething"})); + assertThat(output.getPropertyValues(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE), + JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE, + 4), + JavaMetadataLexicon.PARAMETER, + JavaMetadataLexicon.FORMAL_PARAMETER, + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE), "java:primitiveTypeName"), is(new Object[] {"int"})); - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[4]/java:parameter/java:formalParameter[1]/java:type/java:primitiveType/java:primitiveVariable/java:variable", - "java:variableName"), - is(new Object[] {"p1"})); - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[4]/java:parameter/java:formalParameter[2]/java:type/java:primitiveType", - "java:primitiveTypeName"), + assertThat(output.getPropertyValues(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE), + JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE, + 4), + JavaMetadataLexicon.PARAMETER, + JavaMetadataLexicon.FORMAL_PARAMETER, + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE, + JavaMetadataLexicon.PRIMITIVE_TYPE_VARIABLE, + JavaMetadataLexicon.VARIABLE), "java:variableName"), is(new Object[] {"p1"})); + assertThat(output.getPropertyValues(path(path(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE), + JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE, + 4), JavaMetadataLexicon.PARAMETER), + JavaMetadataLexicon.FORMAL_PARAMETER, + 2), + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE), "java:primitiveTypeName"), is(new Object[] {"double"})); - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[4]/java:parameter/java:formalParameter[2]/java:type/java:primitiveType/java:primitiveVariable/java:variable", - "java:variableName"), - is(new Object[] {"p2"})); - - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[4]/java:parameter/java:formalParameter[3]/java:type/java:simpleType", - "java:simpleTypeName"), + assertThat(output.getPropertyValues(path(path(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE), + JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE, + 4), JavaMetadataLexicon.PARAMETER), + JavaMetadataLexicon.FORMAL_PARAMETER, + 2), + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE, + JavaMetadataLexicon.PRIMITIVE_TYPE_VARIABLE, + JavaMetadataLexicon.VARIABLE), "java:variableName"), is(new Object[] {"p2"})); + + assertThat(output.getPropertyValues(path(path(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE), + JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE, + 4), JavaMetadataLexicon.PARAMETER), + JavaMetadataLexicon.FORMAL_PARAMETER, + 3), + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.SIMPLE_TYPE_CHILD_NODE), "java:simpleTypeName"), is(new Object[] {"Object"})); - assertThat(output.getPropertyValues("java:compilationUnit/java:unitType/java:classDeclaration/java:normalClass/java:normalClassDeclaration/java:method/java:methodDeclaration[4]/java:parameter/java:formalParameter[3]/java:type/java:simpleType/java:simpleTypeVariable/java:variable", - "java:variableName"), - is(new Object[] {"o"})); + assertThat(output.getPropertyValues(path(path(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE), + JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE, + 4), JavaMetadataLexicon.PARAMETER), + JavaMetadataLexicon.FORMAL_PARAMETER, + 3), + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.SIMPLE_TYPE_CHILD_NODE, + JavaMetadataLexicon.SIMPLE_TYPE_VARIABLE, + JavaMetadataLexicon.VARIABLE), "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"), + assertThat(output.getPropertyValues(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE), + JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE, + 5), + JavaMetadataLexicon.MODIFIER_CHILD_NODE, + JavaMetadataLexicon.MODIFIER_DECLARATION_CHILD_NODE), "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"), + assertThat(output.getPropertyValues(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE), + JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE, + 5), + JavaMetadataLexicon.RETURN_TYPE, + JavaMetadataLexicon.PRIMITIVE_TYPE_CHILD_NODE), "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"), + assertThat(output.getPropertyValues(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE), + JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE, + 5), "java:methodName"), is(new Object[] {"doSomething2"})); + assertThat(output.getPropertyValues(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE), + JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE, + 5), + JavaMetadataLexicon.PARAMETER, + JavaMetadataLexicon.FORMAL_PARAMETER, + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.ARRAY_TYPE_CHILD_NODE), "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"), + assertThat(output.getPropertyValues(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE), + JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE, + 5), + JavaMetadataLexicon.PARAMETER, + JavaMetadataLexicon.FORMAL_PARAMETER, + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.ARRAY_TYPE_CHILD_NODE, + JavaMetadataLexicon.ARRAY_TYPE_VARIABLE, + JavaMetadataLexicon.VARIABLE), "java:variableName"), is(new Object[] {"oa"})); + + assertThat(output.getPropertyValues(path(path(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE), + JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE, + 5), JavaMetadataLexicon.PARAMETER), + JavaMetadataLexicon.FORMAL_PARAMETER, + 2), + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.ARRAY_TYPE_CHILD_NODE), "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"})); + assertThat(output.getPropertyValues(path(path(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE), + JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE, + 5), JavaMetadataLexicon.PARAMETER), + JavaMetadataLexicon.FORMAL_PARAMETER, + 2), + JavaMetadataLexicon.TYPE_CHILD_NODE, + JavaMetadataLexicon.ARRAY_TYPE_CHILD_NODE, + JavaMetadataLexicon.ARRAY_TYPE_VARIABLE, + JavaMetadataLexicon.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"), + assertThat(output.getPropertyValues(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE), + JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE, + 6), + JavaMetadataLexicon.MODIFIER_CHILD_NODE, + JavaMetadataLexicon.MODIFIER_DECLARATION_CHILD_NODE), "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"), + assertThat(output.getPropertyValues(path(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE), + JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE, + 6), + JavaMetadataLexicon.RETURN_TYPE, + JavaMetadataLexicon.SIMPLE_TYPE_CHILD_NODE), "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"})); + assertThat(output.getPropertyValues(path(path(JavaMetadataLexicon.COMPILATION_UNIT_NODE, + JavaMetadataLexicon.UNIT_TYPE_CHILD_NODE, + JavaMetadataLexicon.CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_CHILD_NODE, + JavaMetadataLexicon.NORMAL_CLASS_DECLARATION_CHILD_NODE, + JavaMetadataLexicon.METHOD_CHILD_NODE), + JavaMetadataLexicon.METHOD_DECLARATION_CHILD_NODE, + 6), "java:methodName"), is(new Object[] {"doSomething3"})); } - } Index: extensions/modeshape-sequencer-mp3/src/main/java/org/modeshape/sequencer/mp3/Mp3MetadataLexicon.java new file mode 100644 =================================================================== --- /dev/null (revision 1852) +++ extensions/modeshape-sequencer-mp3/src/main/java/org/modeshape/sequencer/mp3/Mp3MetadataLexicon.java (working copy) @@ -0,0 +1,25 @@ +package org.modeshape.sequencer.mp3; + +import net.jcip.annotations.Immutable; +import org.modeshape.graph.property.Name; +import org.modeshape.graph.property.basic.BasicName; + +/** + * A lexicon of names used within the mp3 sequencer. + */ +@Immutable +public class Mp3MetadataLexicon { + + public static class Namespace { + public static final String URI = "http://www.modeshape.org/mp3/1.0"; + public static final String PREFIX = "mp3"; + } + + public static final Name METADATA_NODE = new BasicName(Namespace.URI, "metadata"); + public static final Name TITLE = new BasicName(Namespace.URI, "title"); + public static final Name AUTHOR = new BasicName(Namespace.URI, "author"); + public static final Name ALBUM = new BasicName(Namespace.URI, "album"); + public static final Name YEAR = new BasicName(Namespace.URI, "year"); + public static final Name COMMENT = new BasicName(Namespace.URI, "comment"); + +} Index: extensions/modeshape-sequencer-mp3/src/main/java/org/modeshape/sequencer/mp3/Mp3MetadataSequencer.java =================================================================== --- extensions/modeshape-sequencer-mp3/src/main/java/org/modeshape/sequencer/mp3/Mp3MetadataSequencer.java (revision 1852) +++ extensions/modeshape-sequencer-mp3/src/main/java/org/modeshape/sequencer/mp3/Mp3MetadataSequencer.java (working copy) @@ -24,6 +24,8 @@ package org.modeshape.sequencer.mp3; import java.io.InputStream; +import org.modeshape.graph.JcrLexicon; +import org.modeshape.graph.property.Path; import org.modeshape.graph.sequencer.SequencerOutput; import org.modeshape.graph.sequencer.StreamSequencer; import org.modeshape.graph.sequencer.StreamSequencerContext; @@ -48,14 +50,6 @@ import org.modeshape.graph.sequencer.StreamSequencerContext; */ public class Mp3MetadataSequencer implements StreamSequencer { - public static final String METADATA_NODE = "mp3:metadata"; - public static final String MP3_PRIMARY_TYPE = "jcr:primaryType"; - public static final String MP3_TITLE = "mp3:title"; - public static final String MP3_AUTHOR = "mp3:author"; - public static final String MP3_ALBUM = "mp3:album"; - public static final String MP3_YEAR = "mp3:year"; - public static final String MP3_COMMENT = "mp3:comment"; - /** * {@inheritDoc} * @@ -68,12 +62,14 @@ public class Mp3MetadataSequencer implements StreamSequencer { if (metadata != null) { // Place the image metadata into the output map ... - output.setProperty(METADATA_NODE, MP3_PRIMARY_TYPE, "mp3:metadata"); - output.setProperty(METADATA_NODE, MP3_TITLE, metadata.getTitle()); - output.setProperty(METADATA_NODE, MP3_AUTHOR, metadata.getAuthor()); - output.setProperty(METADATA_NODE, MP3_ALBUM, metadata.getAlbum()); - output.setProperty(METADATA_NODE, MP3_YEAR, metadata.getYear()); - output.setProperty(METADATA_NODE, MP3_COMMENT, metadata.getComment()); + Path metadataNode = context.getValueFactories().getPathFactory().createRelativePath(Mp3MetadataLexicon.METADATA_NODE); + + output.setProperty(metadataNode, JcrLexicon.PRIMARY_TYPE, "mp3:metadata"); + output.setProperty(metadataNode, Mp3MetadataLexicon.TITLE, metadata.getTitle()); + output.setProperty(metadataNode, Mp3MetadataLexicon.AUTHOR, metadata.getAuthor()); + output.setProperty(metadataNode, Mp3MetadataLexicon.ALBUM, metadata.getAlbum()); + output.setProperty(metadataNode, Mp3MetadataLexicon.YEAR, metadata.getYear()); + output.setProperty(metadataNode, Mp3MetadataLexicon.COMMENT, metadata.getComment()); } } } Index: extensions/modeshape-sequencer-msoffice/src/main/java/org/modeshape/sequencer/msoffice/MSOfficeMetadataLexicon.java new file mode 100644 =================================================================== --- /dev/null (revision 1852) +++ extensions/modeshape-sequencer-msoffice/src/main/java/org/modeshape/sequencer/msoffice/MSOfficeMetadataLexicon.java (working copy) @@ -0,0 +1,45 @@ +package org.modeshape.sequencer.msoffice; + +import net.jcip.annotations.Immutable; +import org.modeshape.graph.property.Name; +import org.modeshape.graph.property.basic.BasicName; + +/** + * A lexicon of names used within the MS Office sequencer. + */ +@Immutable +public class MSOfficeMetadataLexicon { + + public static class Namespace { + public static final String URI = "http://www.modeshape.org/msoffice/1.0"; + public static final String PREFIX = "msoffice"; + } + + public static final Name METADATA_NODE = new BasicName(Namespace.URI, "metadata"); + public static final Name TITLE = new BasicName(Namespace.URI, "title"); + public static final Name SUBJECT = new BasicName(Namespace.URI, "subject"); + public static final Name AUTHOR = new BasicName(Namespace.URI, "author"); + public static final Name KEYWORDS = new BasicName(Namespace.URI, "keywords"); + public static final Name COMMENT = new BasicName(Namespace.URI, "comment"); + public static final Name TEMPLATE = new BasicName(Namespace.URI, "template"); + public static final Name LAST_SAVED_BY = new BasicName(Namespace.URI, "last_saved_by"); + public static final Name REVISION = new BasicName(Namespace.URI, "revision"); + public static final Name TOTAL_EDITING_TIME = new BasicName(Namespace.URI, "total_editing_time"); + public static final Name LAST_PRINTED = new BasicName(Namespace.URI, "last_printed"); + public static final Name CREATED = new BasicName(Namespace.URI, "created"); + public static final Name SAVED = new BasicName(Namespace.URI, "saved"); + public static final Name PAGES = new BasicName(Namespace.URI, "pages"); + public static final Name WORDS = new BasicName(Namespace.URI, "words"); + public static final Name CHARACTERS = new BasicName(Namespace.URI, "characters"); + public static final Name CREATING_APPLICATION = new BasicName(Namespace.URI, "creating_application"); + public static final Name THUMBNAIL = new BasicName(Namespace.URI, "thumbnail"); + public static final Name SLIDE = new BasicName(Namespace.URI, "slide"); + public static final Name TEXT = new BasicName(Namespace.URI, "text"); + public static final Name NOTES = new BasicName(Namespace.URI, "notes"); + public static final Name FULL_CONTENT = new BasicName(Namespace.URI, "full_contents"); + public static final Name SHEET_NAME = new BasicName(Namespace.URI, "sheet_name"); + public static final Name HEADING_NODE = new BasicName(Namespace.URI, "heading"); + public static final Name HEADING_NAME = new BasicName(Namespace.URI, "heading_name"); + public static final Name HEADING_LEVEL = new BasicName(Namespace.URI, "heading_level"); + +} Index: extensions/modeshape-sequencer-msoffice/src/main/java/org/modeshape/sequencer/msoffice/MSOfficeMetadataSequencer.java =================================================================== --- extensions/modeshape-sequencer-msoffice/src/main/java/org/modeshape/sequencer/msoffice/MSOfficeMetadataSequencer.java (revision 1852) +++ extensions/modeshape-sequencer-msoffice/src/main/java/org/modeshape/sequencer/msoffice/MSOfficeMetadataSequencer.java (working copy) @@ -27,6 +27,9 @@ import java.io.IOException; import java.io.InputStream; import java.util.Iterator; import java.util.List; +import org.modeshape.graph.JcrLexicon; +import org.modeshape.graph.property.Path; +import org.modeshape.graph.property.PathFactory; import org.modeshape.graph.sequencer.SequencerOutput; import org.modeshape.graph.sequencer.StreamSequencer; import org.modeshape.graph.sequencer.StreamSequencerContext; @@ -79,42 +82,6 @@ import org.modeshape.sequencer.msoffice.word.WordMetadataReader; */ public class MSOfficeMetadataSequencer implements StreamSequencer { - public static final String METADATA_NODE = "msoffice:metadata"; - public static final String MSOFFICE_PRIMARY_TYPE = "jcr:primaryType"; - public static final String MSOFFICE_TITLE = "msoffice:title"; - public static final String MSOFFICE_SUBJECT = "msoffice:subject"; - public static final String MSOFFICE_AUTHOR = "msoffice:author"; - public static final String MSOFFICE_KEYWORDS = "msoffice:keywords"; - public static final String MSOFFICE_COMMENT = "msoffice:comment"; - public static final String MSOFFICE_TEMPLATE = "msoffice:template"; - public static final String MSOFFICE_LAST_SAVED_BY = "msoffice:last_saved_by"; - public static final String MSOFFICE_REVISION = "msoffice:revision"; - public static final String MSOFFICE_TOTAL_EDITING_TIME = "msoffice:total_editing_time"; - public static final String MSOFFICE_LAST_PRINTED = "msoffice:last_printed"; - public static final String MSOFFICE_CREATED = "msoffice:created"; - public static final String MSOFFICE_SAVED = "msoffice:saved"; - public static final String MSOFFICE_PAGES = "msoffice:pages"; - public static final String MSOFFICE_WORDS = "msoffice:words"; - public static final String MSOFFICE_CHARACTERS = "msoffice:characters"; - public static final String MSOFFICE_CREATING_APPLICATION = "msoffice:creating_application"; - public static final String MSOFFICE_THUMBNAIL = "msoffice:thumbnail"; - - // PowerPoint specific - public static final String POWERPOINT_SLIDE_NODE = "msoffice:slide"; - public static final String SLIDE_TITLE = "msoffice:title"; - public static final String SLIDE_TEXT = "msoffice:text"; - public static final String SLIDE_NOTES = "msoffice:notes"; - public static final String SLIDE_THUMBNAIL = "msoffice:thumbnail"; - - // Excel specific - public static final String EXCEL_FULL_CONTENT = "msoffice:full_contents"; - public static final String EXCEL_SHEET_NAME = "msoffice:sheet_name"; - - // Word specific - public static final String WORD_HEADING_NODE = "msoffice:heading"; - public static final String WORD_HEADING_NAME = "msoffice:heading_name"; - public static final String WORD_HEADING_LEVEL = "msoffice:heading_level"; - /** * {@inheritDoc} */ @@ -125,26 +92,28 @@ public class MSOfficeMetadataSequencer implements StreamSequencer { MSOfficeMetadata metadata = MSOfficeMetadataReader.instance(stream); String mimeType = context.getMimeType(); + PathFactory pathFactory = context.getValueFactories().getPathFactory(); + Path metadataNode = pathFactory.create(MSOfficeMetadataLexicon.METADATA_NODE); if (metadata != null) { - output.setProperty(METADATA_NODE, MSOFFICE_PRIMARY_TYPE, "msoffice:metadata"); - output.setProperty(METADATA_NODE, MSOFFICE_TITLE, metadata.getTitle()); - output.setProperty(METADATA_NODE, MSOFFICE_SUBJECT, metadata.getSubject()); - output.setProperty(METADATA_NODE, MSOFFICE_AUTHOR, metadata.getAuthor()); - output.setProperty(METADATA_NODE, MSOFFICE_KEYWORDS, metadata.getKeywords()); - output.setProperty(METADATA_NODE, MSOFFICE_COMMENT, metadata.getComment()); - output.setProperty(METADATA_NODE, MSOFFICE_TEMPLATE, metadata.getTemplate()); - output.setProperty(METADATA_NODE, MSOFFICE_LAST_SAVED_BY, metadata.getLastSavedBy()); - output.setProperty(METADATA_NODE, MSOFFICE_REVISION, metadata.getRevision()); - output.setProperty(METADATA_NODE, MSOFFICE_TOTAL_EDITING_TIME, metadata.getTotalEditingTime()); - output.setProperty(METADATA_NODE, MSOFFICE_LAST_PRINTED, metadata.getLastPrinted()); - output.setProperty(METADATA_NODE, MSOFFICE_CREATED, metadata.getCreated()); - output.setProperty(METADATA_NODE, MSOFFICE_SAVED, metadata.getSaved()); - output.setProperty(METADATA_NODE, MSOFFICE_PAGES, metadata.getPages()); - output.setProperty(METADATA_NODE, MSOFFICE_WORDS, metadata.getWords()); - output.setProperty(METADATA_NODE, MSOFFICE_CHARACTERS, metadata.getCharacters()); - output.setProperty(METADATA_NODE, MSOFFICE_CREATING_APPLICATION, metadata.getCreatingApplication()); - output.setProperty(METADATA_NODE, MSOFFICE_THUMBNAIL, metadata.getThumbnail()); + output.setProperty(metadataNode, JcrLexicon.PRIMARY_TYPE, MSOfficeMetadataLexicon.METADATA_NODE); + output.setProperty(metadataNode, MSOfficeMetadataLexicon.TITLE, metadata.getTitle()); + output.setProperty(metadataNode, MSOfficeMetadataLexicon.SUBJECT, metadata.getSubject()); + output.setProperty(metadataNode, MSOfficeMetadataLexicon.AUTHOR, metadata.getAuthor()); + output.setProperty(metadataNode, MSOfficeMetadataLexicon.KEYWORDS, metadata.getKeywords()); + output.setProperty(metadataNode, MSOfficeMetadataLexicon.COMMENT, metadata.getComment()); + output.setProperty(metadataNode, MSOfficeMetadataLexicon.TEMPLATE, metadata.getTemplate()); + output.setProperty(metadataNode, MSOfficeMetadataLexicon.LAST_SAVED_BY, metadata.getLastSavedBy()); + output.setProperty(metadataNode, MSOfficeMetadataLexicon.REVISION, metadata.getRevision()); + output.setProperty(metadataNode, MSOfficeMetadataLexicon.TOTAL_EDITING_TIME, metadata.getTotalEditingTime()); + output.setProperty(metadataNode, MSOfficeMetadataLexicon.LAST_PRINTED, metadata.getLastPrinted()); + output.setProperty(metadataNode, MSOfficeMetadataLexicon.CREATED, metadata.getCreated()); + output.setProperty(metadataNode, MSOfficeMetadataLexicon.SAVED, metadata.getSaved()); + output.setProperty(metadataNode, MSOfficeMetadataLexicon.PAGES, metadata.getPages()); + output.setProperty(metadataNode, MSOfficeMetadataLexicon.WORDS, metadata.getWords()); + output.setProperty(metadataNode, MSOfficeMetadataLexicon.CHARACTERS, metadata.getCharacters()); + output.setProperty(metadataNode, MSOfficeMetadataLexicon.CREATING_APPLICATION, metadata.getCreatingApplication()); + output.setProperty(metadataNode, MSOfficeMetadataLexicon.THUMBNAIL, metadata.getThumbnail()); } else { return; @@ -155,11 +124,12 @@ public class MSOfficeMetadataSequencer implements StreamSequencer { try { List ppt_metadata = PowerPointMetadataReader.instance(stream); if (ppt_metadata != null) { + Path pptPath = pathFactory.create(metadataNode, MSOfficeMetadataLexicon.SLIDE); for (SlideMetadata sm : ppt_metadata) { - output.setProperty(METADATA_NODE + "/" + POWERPOINT_SLIDE_NODE, SLIDE_TITLE, sm.getTitle()); - output.setProperty(METADATA_NODE + "/" + POWERPOINT_SLIDE_NODE, SLIDE_TEXT, sm.getText()); - output.setProperty(METADATA_NODE + "/" + POWERPOINT_SLIDE_NODE, SLIDE_NOTES, sm.getNotes()); - output.setProperty(METADATA_NODE + "/" + POWERPOINT_SLIDE_NODE, SLIDE_THUMBNAIL, sm.getThumbnail()); + output.setProperty(pptPath, MSOfficeMetadataLexicon.TITLE, sm.getTitle()); + output.setProperty(pptPath, MSOfficeMetadataLexicon.TEXT, sm.getText()); + output.setProperty(pptPath, MSOfficeMetadataLexicon.NOTES, sm.getNotes()); + output.setProperty(pptPath, MSOfficeMetadataLexicon.THUMBNAIL, sm.getThumbnail()); } } } catch (IOException e) { @@ -172,12 +142,13 @@ public class MSOfficeMetadataSequencer implements StreamSequencer { // Sometime in the future this will sequence WORD Table of contents. try { WordMetadata wordMetadata = WordMetadataReader.instance(stream); + Path wordPath = pathFactory.create(metadataNode, MSOfficeMetadataLexicon.HEADING_NODE); for (Iterator iter = wordMetadata.getHeadings().iterator(); iter.hasNext();) { WordMetadata.WordHeading heading = iter.next(); - output.setProperty(METADATA_NODE + "/" + WORD_HEADING_NODE, WORD_HEADING_NAME, heading.getText()); - output.setProperty(METADATA_NODE + "/" + WORD_HEADING_NODE, WORD_HEADING_LEVEL, heading.getHeaderLevel()); + output.setProperty(wordPath, MSOfficeMetadataLexicon.HEADING_NAME, heading.getText()); + output.setProperty(wordPath, MSOfficeMetadataLexicon.HEADING_LEVEL, heading.getHeaderLevel()); } @@ -192,9 +163,9 @@ public class MSOfficeMetadataSequencer implements StreamSequencer { try { ExcelMetadata excel_metadata = ExcelMetadataReader.instance(stream); if (excel_metadata != null) { - output.setProperty(METADATA_NODE, EXCEL_FULL_CONTENT, excel_metadata.getText()); + output.setProperty(metadataNode, MSOfficeMetadataLexicon.FULL_CONTENT, excel_metadata.getText()); for (String sheet : excel_metadata.getSheets()) { - output.setProperty(METADATA_NODE, EXCEL_SHEET_NAME, sheet); + output.setProperty(metadataNode, MSOfficeMetadataLexicon.SHEET_NAME, sheet); } } } catch (IOException e) { Index: extensions/modeshape-sequencer-text/src/test/java/org/modeshape/sequencer/text/DelimitedTextSequencerTest.java =================================================================== --- extensions/modeshape-sequencer-text/src/test/java/org/modeshape/sequencer/text/DelimitedTextSequencerTest.java (revision 1852) +++ extensions/modeshape-sequencer-text/src/test/java/org/modeshape/sequencer/text/DelimitedTextSequencerTest.java (working copy) @@ -27,15 +27,18 @@ import static org.hamcrest.core.Is.is; import static org.hamcrest.core.IsNull.notNullValue; import static org.junit.Assert.assertThat; import java.io.InputStream; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; import org.modeshape.graph.JcrNtLexicon; import org.modeshape.graph.property.Name; +import org.modeshape.graph.property.NameFactory; +import org.modeshape.graph.property.Path; +import org.modeshape.graph.property.PathFactory; import org.modeshape.graph.sequencer.MockSequencerContext; import org.modeshape.graph.sequencer.MockSequencerOutput; import org.modeshape.graph.sequencer.SequencerOutput; import org.modeshape.graph.sequencer.StreamSequencerContext; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; public class DelimitedTextSequencerTest { private DelimitedTextSequencer sequencer; @@ -268,8 +271,12 @@ public class DelimitedTextSequencerTest { public void recordRow( StreamSequencerContext context, SequencerOutput output, String[] columns ) { + PathFactory pathFactory = context.getValueFactories().getPathFactory(); + NameFactory nameFactory = context.getValueFactories().getNameFactory(); for (int i = 0; i < columns.length; i++) { - output.setProperty("text:row[" + rowNum + "]", "text:data" + i, columns[i]); + Path path = pathFactory.createRelativePath(pathFactory.createSegment(TextSequencerLexicon.ROW, rowNum)); + Name name = nameFactory.create(TextSequencerLexicon.Namespace.URI, "data" + i); + output.setProperty(path, name, columns[i]); } rowNum++; Index: extensions/modeshape-sequencer-text/src/test/java/org/modeshape/sequencer/text/FixedWidthTextSequencerTest.java =================================================================== --- extensions/modeshape-sequencer-text/src/test/java/org/modeshape/sequencer/text/FixedWidthTextSequencerTest.java (revision 1852) +++ extensions/modeshape-sequencer-text/src/test/java/org/modeshape/sequencer/text/FixedWidthTextSequencerTest.java (working copy) @@ -27,15 +27,18 @@ import static org.hamcrest.core.Is.is; import static org.hamcrest.core.IsNull.notNullValue; import static org.junit.Assert.assertThat; import java.io.InputStream; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; import org.modeshape.graph.JcrNtLexicon; import org.modeshape.graph.property.Name; +import org.modeshape.graph.property.NameFactory; +import org.modeshape.graph.property.Path; +import org.modeshape.graph.property.PathFactory; import org.modeshape.graph.sequencer.MockSequencerContext; import org.modeshape.graph.sequencer.MockSequencerOutput; import org.modeshape.graph.sequencer.SequencerOutput; import org.modeshape.graph.sequencer.StreamSequencerContext; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; public class FixedWidthTextSequencerTest { private FixedWidthTextSequencer sequencer; @@ -213,8 +216,12 @@ public class FixedWidthTextSequencerTest { public void recordRow( StreamSequencerContext context, SequencerOutput output, String[] columns ) { + PathFactory pathFactory = context.getValueFactories().getPathFactory(); + NameFactory nameFactory = context.getValueFactories().getNameFactory(); for (int i = 0; i < columns.length; i++) { - output.setProperty("text:row[" + rowNum + "]", "text:data" + i, columns[i]); + Path path = pathFactory.createRelativePath(pathFactory.createSegment(TextSequencerLexicon.ROW, rowNum)); + Name name = nameFactory.create(TextSequencerLexicon.Namespace.URI, "data" + i); + output.setProperty(path, name, columns[i]); } rowNum++; Index: extensions/modeshape-sequencer-zip/pom.xml =================================================================== --- extensions/modeshape-sequencer-zip/pom.xml (revision 1852) +++ extensions/modeshape-sequencer-zip/pom.xml (working copy) @@ -29,17 +29,27 @@ modeshape-graph + org.modeshape + modeshape-graph + ${project.version} + test-jar + test + + junit junit-dep 4.4 + test org.hamcrest hamcrest-library + test org.mockito mockito-all + test - - Index: utils/modeshape-jdbc/src/test/resources/security/tck_roles.properties deleted file mode 100644 =================================================================== --- utils/modeshape-jdbc/src/test/resources/security/tck_roles.properties (revision 1852) +++ /dev/null (working copy) @@ -1,7 +0,0 @@ -#=[readonly[.] | readwrite[.]][, [readonly[.] | readwrite[.]]]* -superuser=admin -readwrite=readwrite -readonly=readonly -# defaultWorkspace is the default workspace name for the filesystem TCK test -defaultonly=readwrite.Store.default,readonly.Store.otherWorkspace,readwrite.Store.defaultWorkspace -noaccess=readonly.Store.otherWorkspace Index: utils/modeshape-jdbc/src/test/resources/security/tck_users.properties deleted file mode 100644 =================================================================== --- utils/modeshape-jdbc/src/test/resources/security/tck_users.properties (revision 1852) +++ /dev/null (working copy) @@ -1,6 +0,0 @@ -# = -superuser=superuser -readwrite=readwrite -readonly=readonly -defaultonly=defaultonly -noaccess=noaccess