root/trunk/src/main/groovy/org/chama/builder/model/JavaModelDAOBuilder.groovy

package org.chama.builder.model

import org.chama.builder.java.JavaProperty
import org.chama.db.SqlMapper
import org.chama.Inflection

import groovy.text.Template
import groovy.text.SimpleTemplateEngine
import groovy.util.GroovyScriptEngine
import org.codehaus.groovy.runtime.InvokerHelper

class JavaModelDAOBuilder implements ModelBuilder {
    def dbMetaData
        def packages
        def parentDir
        def templateDir
        def buildType = BUILD_ALL
        def modelToBuild
        def ignoreMethods = ["invokeMethod", 
                             "getMetaClass", 
                             "setMetaClass", 
                             "setProperty", 
                             "getProperty", 
                             "hashCode", 
                             "getClass", 
                             "wait", 
                             "equals", 
                             "notify", 
                             "notifyAll", 
                             "toString"]
        def build() {
            def files =[:]
                //first check the build type
                switch(buildType) {
                    case BUILD_ALL:
                        //get all the tables from the database
                        dbMetaData.tables.each {
                            def modelName = Inflection.singularize(SqlMapper.columnToCamelCaseAll(it.key))
                            buildDAO(modelName)
                            buildModel(modelName)
                            
                        }
                        break
                    case BUILD_MODEL:
                        buildDAO(modelToBuild)
                    buildModel(modelToBuild)
                        break
                }
            
        }
        
        def buildModel(modelName) {
            def engine = new SimpleTemplateEngine()
            
            def modelTable = dbMetaData.getTable(Inflection.pluralize(modelName));
            //first we need to find this model in one of the packages
            //convert packages to file system
            packages = packages.collect { new File(parentDir + it.replace('.', '/')) }
            
            //next see if we can find any models on the file system
            def files = []
            packages.each { dir ->
                dir.eachFileMatch(~/${modelName}\.groovy/) {
                    files.add(it)
                }
            }
            
            //now that we have the groovy models we need the JavaModelTemplate
            def modelTemplateFile = new File(templateDir + "/model/JavaModel.tmpl")
            
            //need to build up all of the properties for adding to the template
                def properties = modelTable.columns.collect {
                        def javaProperty = new JavaProperty(name:SqlMapper.columnToCamelCase(it.name), 
                                        type:SqlMapper.getPropertyType(it.typeName), 
                                        allCamelCaseName:SqlMapper.columnToCamelCaseAll(it.name))
                }
                
                def imports = []
                
                def binding = [packageName:"org.chama.test.models", 
                               imports:imports, 
                               className:modelName, 
                               properties:properties]
                def modelTemplate = engine.createTemplate(modelTemplateFile).make(binding)
                return modelTemplate.toString()
        }
        
        def buildDAO(modelName) {
            def engine = new SimpleTemplateEngine()
            
            def modelTable = dbMetaData.getTable(Inflection.pluralize(modelName));
            //first we need to find this model in one of the packages
            //convert packages to file system
            def dirs = packages.collect { new File(parentDir + it.replace('.', '/')) }
            
            //next see if we can find any models on the file system
            def files = []
            dirs.each { dir ->
                dir.eachFileMatch(~/${modelName}\.groovy/) {
                    files.add(it)
                }
            }
            if(files.size() == 1) {
                def model = files.get(0)
                //easiest thing to do is to grab the first line and get the package
                def packageLine
                model.withReader { reader ->
                        packageLine = reader.readLine()
                }
                def packageName = packageLine.substring(8, packageLine.indexOf(";"))
                def scriptEngine = new GroovyScriptEngine(".", parentDir)
                def clazz = scriptEngine.loadScriptByName("${packageName}.${modelName}")
                def obj = clazz.newInstance()
                def methods = clazz.methods
                        methods = methods.findAll {
                    if(!ignoreMethods.contains(it.name)) {
                        return it
                    }
                }
                def classInterceptor = new ModelInterceptor(obj.class)
                        //def registry = InvokerHelper.instance.metaRegistry
                //registry.setMetaClass(obj.class, classInterceptor)
                obj.setMetaClass(classInterceptor)
                
                def newMethods = []
                methods.each {method ->
                        //passing in the actual method as arguments so we can build it
                        //in the interceptor
                        InvokerHelper.invokeMethod(obj, method.name, method)
                        //grab the method representation we just worked on
                        newMethods.add(classInterceptor.method)
                }
                //set the templateDir on each method so it can build itself
                newMethods.each {newMethod ->
                        newMethod.templateDir = templateDir
                }
                        //now that we have the groovy models we need the JavaModelTemplate
                    def modelTemplateFile = new File(templateDir + "/model/JavaDAO.tmpl")
                    
                    //need to build up all of the properties for adding to the template
                        def properties = modelTable.columns.collect {
                                def javaProperty = new JavaProperty(name:SqlMapper.columnToCamelCase(it.name), 
                                                type:SqlMapper.getPropertyType(it.typeName), 
                                                allCamelCaseName:SqlMapper.columnToCamelCaseAll(it.name))
                        }
                        
                        def imports = ["org.chama.test.models.Band",
                                       "com.sourcebeat.tap101.events.dao.BandDAO"]
                        
                        def binding = [packageName:packageName, 
                                       imports:imports, 
                                       className:modelName, 
                                       properties:properties,
                                       methods:newMethods]
                        def modelTemplate = engine.createTemplate(modelTemplateFile).make(binding)
                        return modelTemplate.toString()
                
            }
            
            
        }

}