Changeset 978


Ignore:
Timestamp:
08/28/10 12:54:10 (18 months ago)
Author:
kasper
Message:

Ticket #382: First draft - needs more testing and marshalling

Location:
AnalyzerBeans/trunk
Files:
26 added
15 edited

Legend:

Unmodified
Added
Removed

  • AnalyzerBeans/trunk/pom.xml

    r970 r978  
    7272                </plugins> 
    7373        </reporting> 
    74         <repositories> 
    75                 <repository> 
    76                         <id>repository.jboss.org</id> 
    77                         <name>JBoss Repository</name> 
    78                         <url>http://repository.jboss.org/maven2</url> 
    79                 </repository> 
     74        <repositories> 
     75                <repository> 
     76                        <id>repository.jboss.org</id> 
     77                        <name>JBoss Repository</name> 
     78                        <url>http://repository.jboss.org/maven2</url> 
     79                </repository> 
    8080        </repositories> 
    8181        <dependencies> 

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/descriptors/ClasspathScanDescriptorProvider.java

    r975 r978  
    2828        private Map<Class<? extends Transformer<?>>, TransformerBeanDescriptor<?>> _transformerBeanDescriptors = new HashMap<Class<? extends Transformer<?>>, TransformerBeanDescriptor<?>>(); 
    2929        private Map<Class<? extends Renderer<?, ?>>, RendererBeanDescriptor> _rendererBeanDescriptors = new HashMap<Class<? extends Renderer<?, ?>>, RendererBeanDescriptor>(); 
     30 
     31        @Override 
     32        public AnalyzerBeanDescriptor<?> getAnalyzerBeanDescriptorByDisplayName( 
     33                        String name) { 
     34                Collection<AnalyzerBeanDescriptor<?>> analyzerBeanDescriptors = getAnalyzerBeanDescriptors(); 
     35                for (AnalyzerBeanDescriptor<?> analyzerBeanDescriptor : analyzerBeanDescriptors) { 
     36                        if (name.equals(analyzerBeanDescriptor.getDisplayName())) { 
     37                                return analyzerBeanDescriptor; 
     38                        } 
     39                } 
     40                return null; 
     41        } 
     42 
     43        @Override 
     44        public TransformerBeanDescriptor<?> getTransformerBeanDescriptorByDisplayName( 
     45                        String name) { 
     46                Collection<TransformerBeanDescriptor<?>> transformerBeanDescriptors = getTransformerBeanDescriptors(); 
     47                for (TransformerBeanDescriptor<?> transformerBeanDescriptor : transformerBeanDescriptors) { 
     48                        if (name.equals(transformerBeanDescriptor.getDisplayName())) { 
     49                                return transformerBeanDescriptor; 
     50                        } 
     51                } 
     52                return null; 
     53        } 
    3054 
    3155        public ClasspathScanDescriptorProvider scanPackage(String packageName, 
    … …  
    79103                                                        .get(analyzerClass); 
    80104                                        if (descriptor == null) { 
    81                                                 descriptor = AnnotationBasedAnalyzerBeanDescriptor.create( 
    82                                                                 analyzerClass); 
     105                                                descriptor = AnnotationBasedAnalyzerBeanDescriptor 
     106                                                                .create(analyzerClass); 
    83107                                                _analyzerBeanDescriptors.put(analyzerClass, descriptor); 
    84108                                        } 
    … …  
    91115                                                        .get(transformerClass); 
    92116                                        if (descriptor == null) { 
    93                                                 descriptor = AnnotationBasedTransformerBeanDescriptor.create( 
    94                                                                 transformerClass); 
     117                                                descriptor = AnnotationBasedTransformerBeanDescriptor 
     118                                                                .create(transformerClass); 
    95119                                                _transformerBeanDescriptors.put(transformerClass, 
    96120                                                                descriptor); 

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/descriptors/DescriptorProvider.java

    r975 r978  
    1919                        Class<A> analyzerBeanClass); 
    2020 
     21        public AnalyzerBeanDescriptor<?> getAnalyzerBeanDescriptorByDisplayName( 
     22                        String name); 
     23 
    2124        public Collection<TransformerBeanDescriptor<?>> getTransformerBeanDescriptors(); 
    2225 
    2326        public <T extends Transformer<?>> TransformerBeanDescriptor<T> getTransformerBeanDescriptorForClass( 
    2427                        Class<T> transformerBeanClass); 
     28 
     29        public TransformerBeanDescriptor<?> getTransformerBeanDescriptorByDisplayName( 
     30                        String name); 
    2531 
    2632        public Collection<RendererBeanDescriptor> getRendererBeanDescriptors(); 

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/descriptors/LazyDescriptorProvider.java

    r975 r978  
    2323                                .get(analyzerBeanClass); 
    2424                if (descriptor == null) { 
    25                         descriptor = AnnotationBasedAnalyzerBeanDescriptor.create( 
    26                                         analyzerBeanClass); 
     25                        descriptor = AnnotationBasedAnalyzerBeanDescriptor 
     26                                        .create(analyzerBeanClass); 
    2727                        _analyzerBeanDescriptors.put(analyzerBeanClass, descriptor); 
    2828                } 
    … …  
    4242        } 
    4343 
     44        @Override 
     45        public AnalyzerBeanDescriptor<?> getAnalyzerBeanDescriptorByDisplayName( 
     46                        String name) { 
     47                Collection<AnalyzerBeanDescriptor<?>> analyzerBeanDescriptors = getAnalyzerBeanDescriptors(); 
     48                for (AnalyzerBeanDescriptor<?> analyzerBeanDescriptor : analyzerBeanDescriptors) { 
     49                        if (name.equals(analyzerBeanDescriptor.getDisplayName())) { 
     50                                return analyzerBeanDescriptor; 
     51                        } 
     52                } 
     53                return null; 
     54        } 
     55 
     56        @Override 
     57        public TransformerBeanDescriptor<?> getTransformerBeanDescriptorByDisplayName( 
     58                        String name) { 
     59                Collection<TransformerBeanDescriptor<?>> transformerBeanDescriptors = getTransformerBeanDescriptors(); 
     60                for (TransformerBeanDescriptor<?> transformerBeanDescriptor : transformerBeanDescriptors) { 
     61                        if (name.equals(transformerBeanDescriptor.getDisplayName())) { 
     62                                return transformerBeanDescriptor; 
     63                        } 
     64                } 
     65                return null; 
     66        } 
     67 
    4468        @SuppressWarnings("unchecked") 
    4569        @Override 
    … …  
    4973                                .get(transformerBeanClass); 
    5074                if (descriptor == null) { 
    51                         descriptor = AnnotationBasedTransformerBeanDescriptor.create( 
    52                                         transformerBeanClass); 
     75                        descriptor = AnnotationBasedTransformerBeanDescriptor 
     76                                        .create(transformerBeanClass); 
    5377                        _transformerBeanDescriptors.put(transformerBeanClass, descriptor); 
    5478                } 

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/descriptors/SimpleDescriptorProvider.java

    r975 r978  
    170170                } 
    171171        } 
     172 
     173        @Override 
     174        public AnalyzerBeanDescriptor<?> getAnalyzerBeanDescriptorByDisplayName( 
     175                        String name) { 
     176                Collection<AnalyzerBeanDescriptor<?>> analyzerBeanDescriptors = getAnalyzerBeanDescriptors(); 
     177                for (AnalyzerBeanDescriptor<?> analyzerBeanDescriptor : analyzerBeanDescriptors) { 
     178                        if (name.equals(analyzerBeanDescriptor.getDisplayName())) { 
     179                                return analyzerBeanDescriptor; 
     180                        } 
     181                } 
     182                return null; 
     183        } 
     184 
     185        @Override 
     186        public TransformerBeanDescriptor<?> getTransformerBeanDescriptorByDisplayName( 
     187                        String name) { 
     188                Collection<TransformerBeanDescriptor<?>> transformerBeanDescriptors = getTransformerBeanDescriptors(); 
     189                for (TransformerBeanDescriptor<?> transformerBeanDescriptor : transformerBeanDescriptors) { 
     190                        if (name.equals(transformerBeanDescriptor.getDisplayName())) { 
     191                                return transformerBeanDescriptor; 
     192                        } 
     193                } 
     194                return null; 
     195        } 
    172196} 

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/job/AnalysisJobBuilder.java

    r975 r978  
    77import java.util.List; 
    88 
     9import org.eobjects.analyzer.beans.ExploringAnalyzer; 
    910import org.eobjects.analyzer.beans.RowProcessingAnalyzer; 
    1011import org.eobjects.analyzer.beans.Transformer; 
    … …  
    2627        private List<MetaModelInputColumn> _sourceColumns = new ArrayList<MetaModelInputColumn>(); 
    2728        private List<TransformerJobBuilder<?>> _transformerJobBuilders = new ArrayList<TransformerJobBuilder<?>>(); 
    28         private List<RowProcessingAnalyzerJobBuilder<?>> _analyzerJobBuilders = new ArrayList<RowProcessingAnalyzerJobBuilder<?>>(); 
     29        private List<AnalyzerJobBuilder<?>> _analyzerJobBuilders = new ArrayList<AnalyzerJobBuilder<?>>(); 
    2930        private IdGenerator transformedColumnIdGenerator = new PrefixedIdGenerator( 
    3031                        "trans"); 
    … …  
    139140        } 
    140141 
    141         public List<RowProcessingAnalyzerJobBuilder<?>> getAnalyzerJobBuilders() { 
     142        public List<AnalyzerJobBuilder<?>> getAnalyzerJobBuilders() { 
    142143                return Collections.unmodifiableList(_analyzerJobBuilders); 
    143144        } 
    144145 
    145         public <A extends RowProcessingAnalyzer<?>> RowProcessingAnalyzerJobBuilder<A> addAnalyzer( 
     146        public <A extends ExploringAnalyzer<?>> ExploringAnalyzerJobBuilder<A> addExploringAnalyzer( 
     147                        Class<A> analyzerClass) { 
     148                AnalyzerBeanDescriptor<A> descriptor = _configuration 
     149                                .getDescriptorProvider().getAnalyzerBeanDescriptorForClass( 
     150                                                analyzerClass); 
     151                if (descriptor == null) { 
     152                        throw new IllegalArgumentException("No descriptor found for: " 
     153                                        + analyzerClass); 
     154                } 
     155                ExploringAnalyzerJobBuilder<A> analyzerJobBuilder = new ExploringAnalyzerJobBuilder<A>( 
     156                                descriptor); 
     157                _analyzerJobBuilders.add(analyzerJobBuilder); 
     158                return analyzerJobBuilder; 
     159        } 
     160 
     161        public <A extends RowProcessingAnalyzer<?>> RowProcessingAnalyzerJobBuilder<A> addRowProcessingAnalyzer( 
    146162                        Class<A> analyzerClass) { 
    147163                AnalyzerBeanDescriptor<A> descriptor = _configuration 
    … …  
    212228                } 
    213229 
    214                 for (RowProcessingAnalyzerJobBuilder<?> ajb : _analyzerJobBuilders) { 
     230                for (AnalyzerJobBuilder<?> ajb : _analyzerJobBuilders) { 
    215231                        if (!ajb.isConfigured()) { 
    216232                                return false; 
    … …  
    240256 
    241257                Collection<AnalyzerJob> analyzerJobs = new LinkedList<AnalyzerJob>(); 
    242                 for (RowProcessingAnalyzerJobBuilder<?> ajb : _analyzerJobBuilders) { 
     258                for (AnalyzerJobBuilder<?> ajb : _analyzerJobBuilders) { 
    243259                        try { 
    244260                                AnalyzerJob analyzerJob = ajb.toAnalyzerJob(); 

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/job/ExploringAnalyzerJobBuilder.java

    r975 r978  
    66public class ExploringAnalyzerJobBuilder<A extends ExploringAnalyzer<?>> 
    77                extends 
    8                 AbstractBeanJobBuilder<AnalyzerBeanDescriptor<A>, A, ExploringAnalyzerJobBuilder<A>> { 
     8                AbstractBeanJobBuilder<AnalyzerBeanDescriptor<A>, A, ExploringAnalyzerJobBuilder<A>> 
     9                implements AnalyzerJobBuilder<A> { 
    910 
    1011        public ExploringAnalyzerJobBuilder(AnalyzerBeanDescriptor<A> descriptor) { 
    … …  
    1213        } 
    1314 
     15        @Override 
    1416        public AnalyzerJob toAnalyzerJob() throws IllegalStateException { 
    1517                if (!isConfigured()) { 

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/job/RowProcessingAnalyzerJobBuilder.java

    r975 r978  
    66public class RowProcessingAnalyzerJobBuilder<A extends RowProcessingAnalyzer<?>> 
    77                extends 
    8                 AbstractBeanWithInputColumnsBuilder<AnalyzerBeanDescriptor<A>, A, RowProcessingAnalyzerJobBuilder<A>> { 
     8                AbstractBeanWithInputColumnsBuilder<AnalyzerBeanDescriptor<A>, A, RowProcessingAnalyzerJobBuilder<A>> 
     9                implements AnalyzerJobBuilder<A> { 
    910 
    1011        public RowProcessingAnalyzerJobBuilder(AnalyzerBeanDescriptor<A> descriptor) { 
    … …  
    1213        } 
    1314 
     15        @Override 
    1416        public AnalyzerJob toAnalyzerJob() throws IllegalStateException { 
    1517                if (!isConfigured()) { 

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/util/SchemaNavigator.java

    r967 r978  
    1414        } 
    1515 
     16        public Schema convertToSchema(String schemaName) { 
     17                return dataContext.getSchemaByName(schemaName); 
     18        } 
     19 
    1620        public Schema[] convertToSchemas(String[] schemaNames) { 
    1721                Schema[] result = new Schema[schemaNames.length]; 
    1822                for (int i = 0; i < result.length; i++) { 
    19                         result[i] = dataContext.getSchemaByName(schemaNames[i]); 
     23                        result[i] = convertToSchema(schemaNames[i]); 
    2024                } 
    2125                return result; 
    … …  
    2529                Table[] result = new Table[tableNames.length]; 
    2630                for (int i = 0; i < result.length; i++) { 
    27                         result[i] = dataContext.getTableByQualifiedLabel(tableNames[i]); 
     31                        result[i] = convertToTable(tableNames[i]); 
    2832                } 
    2933                return result; 
     34        } 
     35 
     36        public Table convertToTable(String tableName) { 
     37                return dataContext.getTableByQualifiedLabel(tableName); 
    3038        } 
    3139 
    … …  
    3341                Column[] result = new Column[columnNames.length]; 
    3442                for (int i = 0; i < result.length; i++) { 
    35                         result[i] = dataContext.getColumnByQualifiedLabel(columnNames[i]); 
     43                        result[i] = convertToColumn(columnNames[i]); 
    3644                } 
    3745                return result; 
    3846        } 
     47 
     48        public Column convertToColumn(String columnName) { 
     49                return dataContext.getColumnByQualifiedLabel(columnName); 
     50        } 
    3951} 

  • AnalyzerBeans/trunk/src/test/java/org/eobjects/analyzer/job/AnalysisJobBuilderTest.java

    r975 r978  
    5757        public void testToString() throws Exception { 
    5858                RowProcessingAnalyzerJobBuilder<StringAnalyzer> ajb = analysisJobBuilder 
    59                                 .addAnalyzer(StringAnalyzer.class); 
     59                                .addRowProcessingAnalyzer(StringAnalyzer.class); 
    6060                TransformerJobBuilder<ConvertToStringTransformer> tjb = analysisJobBuilder 
    6161                                .addTransformer(ConvertToStringTransformer.class); 
    … …  
    9898 
    9999                RowProcessingAnalyzerJobBuilder<StringAnalyzer> analyzerJobBuilder = analysisJobBuilder 
    100                                 .addAnalyzer(StringAnalyzer.class); 
     100                                .addRowProcessingAnalyzer(StringAnalyzer.class); 
    101101 
    102102                Collection<InputColumn<?>> stringInputColumns = analysisJobBuilder 

  • AnalyzerBeans/trunk/src/test/java/org/eobjects/analyzer/job/runner/RowProcessingPublisherTest.java

    r975 r978  
    5353                                .addInputColumn(tjb2.getOutputColumns().get(0)); 
    5454 
    55                 ajb.addAnalyzer(StringAnalyzer.class).addInputColumn( 
     55                ajb.addRowProcessingAnalyzer(StringAnalyzer.class).addInputColumn( 
    5656                                ajb.getSourceColumns().get(0)); 
    57                 ajb.addAnalyzer(StringAnalyzer.class).addInputColumn( 
     57                ajb.addRowProcessingAnalyzer(StringAnalyzer.class).addInputColumn( 
    5858                                tjb3.getOutputColumns().get(0)); 
    5959 

  • AnalyzerBeans/trunk/src/test/java/org/eobjects/analyzer/test/TestHelper.java

    r971 r978  
    2929                                        "org.eobjects.analyzer.renderer", true); 
    3030 
     31        public static AnalyzerBeansConfiguration createAnalyzerBeansConfiguration( 
     32                        Datastore datastore) { 
     33                TaskRunner taskRunner = new SingleThreadedTaskRunner(); 
     34                CollectionProvider collectionProvider = new BerkeleyDbCollectionProvider(); 
     35 
     36                List<Datastore> datastores = new LinkedList<Datastore>(); 
     37                datastores.add(datastore); 
     38 
     39                return new AnalyzerBeansConfigurationImpl(new DatastoreCatalogImpl( 
     40                                datastores), createReferenceDataCatalog(), descriptorProvider, 
     41                                taskRunner, collectionProvider); 
     42        } 
     43 
    3144        public static AnalyzerBeansConfiguration createAnalyzerBeansConfiguration() { 
    3245                TaskRunner taskRunner = new SingleThreadedTaskRunner(); 

  • AnalyzerBeans/trunk/src/test/java/org/eobjects/analyzer/test/full/scenarios/NameAndEmailPartEqualityTest.java

    r975 r978  
    104104                assertNotNull(usernameColumn); 
    105105 
    106                 assertTrue(analysisJobBuilder.addAnalyzer(StringAnalyzer.class) 
     106                assertTrue(analysisJobBuilder.addRowProcessingAnalyzer(StringAnalyzer.class) 
    107107                                .addInputColumns(nameColumns) 
    108108                                .addInputColumns(emailTransformerJobBuilder.getOutputColumns()) 
    … …  
    111111                for (InputColumn<?> inputColumn : nameColumns) { 
    112112                        RowProcessingAnalyzerJobBuilder<ValueDistributionAnalyzer> analyzerJobBuilder = analysisJobBuilder 
    113                                         .addAnalyzer(ValueDistributionAnalyzer.class); 
     113                                        .addRowProcessingAnalyzer(ValueDistributionAnalyzer.class); 
    114114                        analyzerJobBuilder.addInputColumn(inputColumn); 
    115115                        analyzerJobBuilder.setConfiguredProperty("Record unique values", 
    … …  
    123123 
    124124                RowProcessingAnalyzerJobBuilder<EqualityAnalyzer> equalsAnalyzerJobBuilder = analysisJobBuilder 
    125                                 .addAnalyzer(EqualityAnalyzer.class); 
     125                                .addRowProcessingAnalyzer(EqualityAnalyzer.class); 
    126126                equalsAnalyzerJobBuilder.addInputColumns( 
    127127                                nameTransformerJobBuilder.getOutputColumnByName("Firstname"), 

  • AnalyzerBeans/trunk/src/test/java/org/eobjects/analyzer/test/full/scenarios/TokenizerAndValueDistributionTest.java

    r975 r978  
    8585                for (InputColumn<?> inputColumn : transformerOutput) { 
    8686                        RowProcessingAnalyzerJobBuilder<ValueDistributionAnalyzer> valueDistribuitionJobBuilder = analysisJobBuilder 
    87                                         .addAnalyzer(ValueDistributionAnalyzer.class); 
     87                                        .addRowProcessingAnalyzer(ValueDistributionAnalyzer.class); 
    8888                        valueDistribuitionJobBuilder.addInputColumn(inputColumn); 
    8989                        valueDistribuitionJobBuilder.setConfiguredProperty( 

  • AnalyzerBeans/trunk/src/test/java/org/eobjects/analyzer/test/full/scenarios/ValueDistributionAndStringAnalysisTest.java

    r975 r978  
    7373                for (InputColumn<?> inputColumn : analysisJobBuilder.getSourceColumns()) { 
    7474                        RowProcessingAnalyzerJobBuilder<ValueDistributionAnalyzer> valueDistribuitionJobBuilder = analysisJobBuilder 
    75                                         .addAnalyzer(ValueDistributionAnalyzer.class); 
     75                                        .addRowProcessingAnalyzer(ValueDistributionAnalyzer.class); 
    7676                        valueDistribuitionJobBuilder.addInputColumn(inputColumn); 
    7777                        valueDistribuitionJobBuilder.setConfiguredProperty( 
    … …  
    8686 
    8787                RowProcessingAnalyzerJobBuilder<StringAnalyzer> stringAnalyzerJob = analysisJobBuilder 
    88                                 .addAnalyzer(StringAnalyzer.class); 
     88                                .addRowProcessingAnalyzer(StringAnalyzer.class); 
    8989                stringAnalyzerJob.addInputColumns(analysisJobBuilder 
    9090                                .getAvailableInputColumns(DataTypeFamily.STRING)); 
Note: See TracChangeset for help on using the changeset viewer.