<project name="grails" default="help">

	<property name="servlet.version" value="2.3"/>
	<property name="path" value="" />

    <taskdef name="groovyc" classname="org.codehaus.groovy.ant.Groovyc" />
    <taskdef name="groovy"  classname="org.codehaus.groovy.ant.Groovy" />

    <target name="help">
		<echo>Usage: grails [target]

Targets:
"create-app"          - Create a new grails app
"create-controller"   - Create a new controller
"create-service"      - Create a new service
"create-domain-class" - Create a new domain class
"create-test-suite"   - Create a new test suite
"generate-controller" - Generates a controller from a domain class
"generate-views"      - Generates the views from a domain class
"generate-all"        - Generates the all artifacts from a domain class
"test-app"            - Run current app's unit tests
"run-app"             - Run the application locally and wait
"create-webtest"      - Create the functional test layout
"run-webtest"         - Run the functional tests for a running app
        </echo>
	</target>


    <target name="init-props">
        <property environment="env"/>
        <fail unless="env.GRAILS_HOME" message="GRAILS_HOME is not set."/>
        <property name="grails.home" location="${env.GRAILS_HOME}"/>
        <groovy >
            // reusable code blocks, a pitty we cannot store Closures in the project...
            properties.lower = 'x[0].toLowerCase() + x[1..-1]'
            properties.caps  = 'x[0].toUpperCase() + x[1..-1]'
            properties.normCaps = '''
                x = x.replaceAll(' ','')
                x = x[0].toUpperCase() + x[1..-1]
                if (x.endsWith(y)) x = x[0..(x.size()-y.size()-1)]
                return x
            '''
        </groovy>
    </target>

    <target name="init" depends="init-props" description="Initialise the current app">
        <mkdir dir="${path}src"/>
        <mkdir dir="${path}src/java"/>
        <mkdir dir="${path}src/groovy"/>
        <mkdir dir="${path}grails-app"/>
        <mkdir dir="${path}grails-app/controllers"/>
        <mkdir dir="${path}grails-app/services"/>
        <mkdir dir="${path}grails-app/domain"/>
        <mkdir dir="${path}grails-app/taglib"/>
        <mkdir dir="${path}grails-app/views"/>
        <mkdir dir="${path}grails-app/views/layouts"/>
        <mkdir dir="${path}grails-app/i18n"/>
        <mkdir dir="${path}grails-app/conf"/>
        <mkdir dir="${path}grails-tests"/>
        <mkdir dir="${path}web-app"/>
        <mkdir dir="${path}web-app"/>
        <mkdir dir="${path}web-app"/>
        <mkdir dir="${path}web-app/js"/>
        <mkdir dir="${path}web-app/css"/>
        <mkdir dir="${path}web-app/WEB-INF/classes"/>
        <!--<mkdir dir="${path}
"/>-->
        <!--<mkdir dir="${path}html"/>-->
        <mkdir dir="${path}lib"/>
        <mkdir dir="${path}spring"/>
        <mkdir dir="${path}hibernate"/>
        <mkdir dir="${grails.home}/dist"/>

        <copy todir="${path}web-app/WEB-INF">
            <fileset dir="${grails.home}/src/war/WEB-INF">
                <include name="applicationContext.xml"/>
            </fileset>
        </copy>
        <copy todir="${path}grails-app">
            <fileset dir="${grails.home}/src/grails/grails-app" />
        </copy>
        <copy file="${grails.home}/src/war/WEB-INF/web${servlet.version}.template.xml" tofile="${path}web-app/WEB-INF/web.template.xml"/>
        <copy file="${grails.home}/src/war/WEB-INF/sitemesh.xml" tofile="${path}web-app/WEB-INF/sitemesh.xml"/>
        <copy todir="${path}web-app/js">
            <fileset dir="${grails.home}/src/war/js"/>
        </copy>
        <copy todir="${path}web-app/css">
            <fileset dir="${grails.home}/src/war/css"/>
        </copy>
        <copy todir="${path}web-app/WEB-INF/tld">
            <fileset dir="${grails.home}/src/war/WEB-INF/tld/${servlet.version}"/>
            <fileset dir="${grails.home}/src/war/WEB-INF/tld" includes="spring.tld"/>
            <fileset dir="${grails.home}/src/war/WEB-INF/tld" includes="grails.tld"/>
        </copy>
        <copy todir="${path}spring">
            <fileset dir="${grails.home}/src/war/WEB-INF/spring">
                <include name="*.xml"/>
            </fileset>
        </copy>
        <touch file="${path}grails-app/i18n/messages.properties"></touch>
    </target>

    <target name="generate-controller" depends="init-props" description="Generates a controller from a domain class">

		<path id="test.classpath">
			<!--<pathelement location="${grails.home}/src/web-app/WEB-INF"/>-->
            <pathelement location="${basedir}/tmp/war/WEB-INF"/>
            <pathelement location="${basedir}/tmp/war/WEB-INF/classes"/>
            <fileset dir="${grails.home}/lib"/>
			<fileset dir="${grails.home}/dist"/>
			<fileset dir="lib"/>
		</path>
		<java classpathref="test.classpath" classname="grails.util.GenerateUtils" fork="true">
             <arg value="controller" />
             <arg value="${domain.class.name}" />
<!--			<jvmarg value="-Xdebug"/>
			<jvmarg value="-Xrunjdwp:transport=dt_socket,address=50010,suspend=y,server=y"/> -->
		</java>
    </target>

    <target name="generate-views" depends="package" description="Generates the views from a domain class">

		<input addproperty="domain.class.name" message="Enter domain class name:" />

		<path id="test.classpath">
            <pathelement location="${basedir}/tmp/war/WEB-INF"/>
            <pathelement location="${basedir}/tmp/war/WEB-INF/classes"/>
            <fileset dir="${grails.home}/lib"/>
			<fileset dir="${grails.home}/dist"/>
			<fileset dir="lib"/>
		</path>
		<java classpathref="test.classpath" classname="grails.util.GenerateUtils" fork="true">
             <arg value="view" />
             <arg value="${domain.class.name}" />
		</java>
    </target>

    <target name="generate-all" depends="package" description="Generates the all artifacts from a domain class">

		<input addproperty="domain.class.name" message="Enter domain class name:" />

		<path id="test.classpath">
            <pathelement location="${basedir}/tmp/war/WEB-INF"/>
            <pathelement location="${basedir}/tmp/war/WEB-INF/classes"/>
            <fileset dir="${grails.home}/lib"/>
			<fileset dir="${grails.home}/dist"/>
			<fileset dir="lib"/>
		</path>
		<java classpathref="test.classpath" classname="grails.util.GenerateUtils" fork="true">
             <arg value="view" />
             <arg value="${domain.class.name}" />
		</java>
		<java classpathref="test.classpath" classname="grails.util.GenerateUtils" fork="true">
             <arg value="controller" />
             <arg value="${domain.class.name}" />
		</java>
    </target>


    <target name="create-app" depends="init-props" description="Create a new grails app">

		<input addproperty="project.name" message="Enter application name:" />

		<antcall target="init">
			<param name="path" value="${project.name}/"/>
		</antcall>

		<groovy>
			def projName = properties."project.name"
			properties."project.class.name" =  Eval.x(projName, properties.lower)
		</groovy>

			<copy 	file="${grails.home}/src/grails/templates/artifacts/DataSource.groovy"
				    tofile="${project.name}/grails-app/conf/ApplicationDataSource.groovy"/>
			<copy 	file="${grails.home}/src/grails/templates/artifacts/BootStrap.groovy"
					tofile="${project.name}/grails-app/conf/ApplicationBootStrap.groovy"/>
	</target>

	<target name="create-controller" depends="init-props" description="Create a new controller">

		<input addproperty="controller.name" message="Enter controller name:" />

		<groovy>
			def ctrlName = properties."controller.name"
			properties."controller.class.name" = Eval.xy(ctrlName,'Controller', properties.normCaps)
		</groovy>

		<copy 	file="${grails.home}/src/grails/templates/artifacts/Controller.groovy"
				tofile="grails-app/controllers/${controller.class.name}Controller.groovy"
                overwrite="false"/>

		<replace 	file="grails-app/controllers/${controller.class.name}Controller.groovy"
					token="@controller.name@"
					value="${controller.class.name}" />
		<echo>Created controller: grails-app/controllers/${controller.class.name}Controller.groovy</echo>
        <property name="test.suite.name" value="${controller.class.name}" />
        <antcall target="internal-create-test-suite"  />
    </target>

	<target name="create-service" depends="init-props" description="Create a new service">

		<input addproperty="service.name" message="Enter service name:" />

        <groovy>
			def serviceName = properties."service.name"
			properties."service.class.name" = Eval.xy(serviceName,'Service', properties.normCaps)
		</groovy>

        <copy 	file="${grails.home}/src/grails/templates/artifacts/Service.groovy"
				tofile="grails-app/services/${service.class.name}Service.groovy"
                overwrite="false"/>

		<replace 	file="grails-app/services/${service.class.name}Service.groovy"
					token="@service.name@"
					value="${service.class.name}" />
		<echo>Created service: grails-app/services/${service.class.name}Service.groovy</echo>
        <property name="test.suite.name" value="${service.class.name}" />
        <antcall target="internal-create-test-suite" inheritall="true" />
    </target>

	<target name="create-domain-class" depends="init-props" description="Create a new domain class">

		<input addproperty="domain.class.name" message="Enter domain class name:" />

         <groovy>
			def domainName = properties."domain.class.name"
			properties."domain.class.name" = Eval.x(domainName, properties.caps)
		</groovy>


        <copy 	file="${grails.home}/src/grails/templates/artifacts/DomainClass.groovy"
            tofile="grails-app/domain/${domain.class.name}.groovy"
            overwrite="false"/>

        <replace 	file="grails-app/domain/${domain.class.name}.groovy"
            token="@domain.class.name@"
            value="${domain.class.name}" />
        <echo>Domain class created: grails-app/domain/${domain.class.name}.groovy</echo>
        <property name="test.suite.name" value="${domain.class.name}" />
        <antcall target="internal-create-test-suite" inheritall="true" />
    </target>

    <target name="create-test-suite" depends="init-props" description="Create a new test suite">

        <input addproperty="test.suite.name" message="Enter test suite name:" />

        <antcall target="internal-create-test-suite" inheritall="true" />

    </target>

    <target name="internal-create-test-suite">
        <groovy>
			def suiteName = properties."test.suite.name"
			properties."test.suite.name" = Eval.xy(suiteName,'Tests', properties.normCaps)
		</groovy>

        <copy 	file="${grails.home}/src/grails/templates/artifacts/Tests.groovy"
            tofile="grails-tests/${test.suite.name}Tests.groovy"
            overwrite="false"/>

        <replace 	file="grails-tests/${test.suite.name}Tests.groovy"
            token="@test.suite.name@"
            value="${test.suite.name}" />
        <echo>Created test suite: grails-tests/${test.suite.name}Tests.groovy</echo>
    </target>

	<target name="clean">
		<delete file="grails-app.war"/>
		<delete dir="tmp" />
	</target>

	<target name="build" depends="init-props">
		<path id="classpath">
			<fileset dir="lib"/>
			<fileset dir="${grails.home}/lib"/>
			<fileset dir="${grails.home}/dist"/>
		</path>
		<delete failonerror="false">
			<fileset dir="web-app/WEB-INF/classes"/>
		</delete>
		<javac srcdir="src/java" destdir="web-app/WEB-INF/classes" classpathref="classpath" debug="on" deprecation="on" optimize="off"/>

		<groovyc srcdir="src/groovy" destdir="web-app/WEB-INF/classes" classpathref="classpath" />
	</target>

	<target name="test" depends="build">
		<delete dir="tmp/reports"/>
		<mkdir dir="tmp/reports"/>
		<path id="test_classpath">
			<fileset dir="lib"/>
			<fileset dir="${grails.home}/lib"/>
			<fileset dir="${grails.home}/dist"/>
			<path location="web-app/WEB-INF/classes"/>
		</path>
		<junit>
			<classpath refid="test_classpath"/>

			<formatter type="plain" usefile="no"/>
			<formatter type="xml"/>
			<batchtest todir="tmp/reports" fork="yes">
				<fileset dir="web-app/WEB-INF/classes" includes="**/*Tests.class" excludes="**/Abstract*"/>
			</batchtest>
		</junit>
	</target>

	<target name="test-app" depends="package" description="Run current app's unit tests">
		<mkdir dir="${basedir}/tmp/war/WEB-INF/grails-app/tests" />
		<copy todir="${basedir}/tmp/war/WEB-INF/grails-app/tests">
			<fileset dir="${basedir}/grails-tests/" includes="**" />
		</copy>
		<path id="test.classpath">
			<!--<pathelement location="${grails.home}/src/web-app/WEB-INF"/>-->
            <pathelement location="${basedir}/tmp/war/WEB-INF"/>
            <pathelement location="${basedir}/tmp/war/WEB-INF/classes"/>
            <fileset dir="${grails.home}/lib"/>
			<fileset dir="${grails.home}/dist"/>
			<fileset dir="lib"/>
		</path>
		<java classpathref="test.classpath" classname="grails.util.RunTests" fork="true">
<!--			<jvmarg value="-Xdebug"/>
			<jvmarg value="-Xrunjdwp:transport=dt_socket,address=50010,suspend=y,server=y"/> -->
		</java>
		<delete dir="${basedir}/tmp/war/WEB-INF/grails-app/tests"></delete>
	</target>

    <target name="dev">
        <property name="dev.run" value="true" />
    </target>

    <target name="package" depends="build">
        <mkdir dir="tmp/war"/>
        <copy todir="tmp/war">
            <fileset dir="web-app">
                <include name="**/**"/>
                <exclude name="WEB-INF/*.template.xml"/>
            </fileset>
        </copy>

        <property name="controllers.home" location="grails-app/controllers"></property>
        <property name="web.xml.template"  location="web-app/WEB-INF/web.template.xml"></property>
        <property name="target.web.xml"  location="tmp/war/WEB-INF/web.xml"></property>
        <property name="tmp.war.dir"  location="tmp/war"></property>
        <property name="project.base.dir"  location="."></property>

        <groovy><![CDATA[
            import groovy.text.SimpleTemplateEngine

            def controllersHome = properties."controllers.home"
            def controllers = []
            def flows = []
            new File("${controllersHome}").eachFileRecurse {
                def match = it.name =~ "(\\w+)(Controller.groovy\$)"
                if(match) {
                    def controllerName = match[0][1]
                    controllerName = Eval.x(controllerName, properties.lower)
                    controllers << controllerName
                }
                match = it.name =~ "(\\w+)(PageFlow.groovy\$)"
                if(match) {
                    def flowName = match[0][1]
                    flowName = Eval.x(flowName, properties.lower)
                    flows << flowName
                }
            }

            def devRun = ("true" == properties."dev.run")

            def binding = [ "controllers" : controllers,
                            "flows" : flows,
                            "basedir" : properties."project.base.dir",
                            "destdir" : properties."tmp.war.dir",
                            "dev" : devRun     ]
            def engine = new SimpleTemplateEngine()
            def template = engine.createTemplate( new File( properties."web.xml.template" ).text ).make(binding)

            new File( properties."target.web.xml" ).write( template.toString() )
        ]]></groovy>


        <mkdir dir="tmp/war/WEB-INF/classes"/>
        <touch file="tmp/war/WEB-INF/classes/.dummy"/>
        <mkdir dir="tmp/war/WEB-INF/lib"/>
        <touch file="tmp/war/WEB-INF/lib/.dummy"/>
        <mkdir dir="tmp/war/WEB-INF/spring"/>
        <touch file="tmp/war/WEB-INF/spring/.dummy"/>
        <mkdir dir="tmp/war/WEB-INF/tld"/>
        <mkdir dir="tmp/war/js"/>
        <copy todir="tmp/war/WEB-INF/lib">
            <fileset dir="${grails.home}/lib">
                <include name="antlr-2.7.6rc1.jar"/>
                <include name="asm.jar"/>
                <include name="asm-attrs.jar"/>
                <include name="cglib-2.1.3.jar"/>
                <include name="dom4j-1.6.1.jar"/>
                <include name="ehcache-1.1.jar"/>
                <include name="ejb-3.0-edr2.jar"/>
                <include name="hibernate3.jar"/>
                <include name="jdbc2_0-stdext.jar"/>
                <include name="jta.jar"/>
                <include name="junit.jar"/>
                <include name="asm-2.0.jar"/>
                <include name="asm-util-2.0.jar"/>
                <include name="commons-logging.jar"/>
                <include name="sitemesh-2.2.1.jar"/>
                <include name="spring-webflow.jar"/>
                <include name="spring-binding.jar"/>
                <include name="spring.jar"/>
                <include name="groovy-all-1.0-jsr-05-SNAPSHOT.jar"/>
                <include name="springmodules-sandbox.jar"/>
                <include name="standard-${servlet.version}.jar"/>
                <include name="jstl-${servlet.version}.jar"/>
                <include name="commons-lang-2.0.jar"/>
                <include name="log4j-1.2.8.jar"/>
                <include name="ognl-2.7.jar"/>
                <include name="hsqldb.jar"/>
                <include name="commons-collections-3.0.jar"/>
                <include name="commons-pool-1.2.jar"/>
                <include name="commons-dbcp-1.2.1.jar"/>
                <include name="commons-cli-1.0.jar"/>
                <include name="commons-validator.jar"/>
                <include name="commons-fileupload.jar"/>
                <include name="jakarta-oro-2.0.8.jar"/>
            </fileset>
            <fileset dir="${grails.home}/dist"/>
            <fileset dir="lib"/>
        </copy>
        <antcall target="package:java5"></antcall>
        <copy todir="tmp/war/WEB-INF/grails-app">
            <fileset dir="grails-app" includes="**"/>
        </copy>
        <copy todir="tmp/war/WEB-INF/classes">
            <fileset dir="grails-app/i18n" includes="**"/>
        </copy>
        <copy todir="tmp/war/WEB-INF/spring">
            <fileset dir="spring" includes="**"/>
        </copy>
        <copy todir="tmp/war/WEB-INF/classes">
            <fileset dir="hibernate" includes="**"/>
        </copy>
        <copy todir="tmp/war/WEB-INF">
            <fileset dir="${grails.home}/src/war/WEB-INF">
                <include name="log4j.properties"/>
            </fileset>
        </copy>
    </target>
    <target name="package:checkj5">
        <condition property="is.java.5">
              <equals arg1="${ant.java.version}" arg2="1.5"/>
        </condition>
    </target>

    <target name="package:java5" depends="package:checkj5" if="is.java.5">
        <copy todir="tmp/war/WEB-INF/lib">
            <fileset dir="${grails.home}/lib">
                <include name="hibernate-annotations.jar"/>
                <include name="ejb3-persistence.jar"/>
            </fileset>
        </copy>
    </target>

    <target name="war" depends="clean,package">
		<basename property="project.dir" file="."/>
		<jar destfile="${project.dir}.war" basedir="tmp/war" />
	</target>

    <target name="run-app:impl">
		<basename property="project.dir" file="."/>

		<groovy>
			import org.mortbay.jetty.*
			import org.mortbay.http.*

            System.setProperty('org.mortbay.xml.XmlParser.NotValidating', 'true')
            def server = new Server()
            try {
                def listener = new SocketListener()
                listener.setPort(8080)
                server.addListener(listener)
                server.addWebApplication("/" + properties."project.dir", 'tmp/war')
                server.start()
                if (properties.'runTests') ant.antcall(target:'webtest-impl')
            } catch(Throwable t) {
                t.printStackTrace()
			} finally {
                if (properties.'runTests') server.stop()
            }
        </groovy>
    </target>

    <target name="wait-forever" >
        <script language="groovy">
            while(true) {
                sleep(Long.MAX_VALUE)
			}
		</script>
	</target>

    <target name="run-app" depends="dev, package" description="Run the application locally and wait">
        <antcall target="run-app:impl" />
        <antcall target="wait-forever" />
    </target>

    <target name="init-webtest" depends="init-props" >
        <!--
            Download WebTest distro if needed.
            Users may need to use the <setproxy/> task to when behind a firewall!
            Downloads are expanded below the downloads dir.
            Todo: expanded dirs need to deleted if download cache is updated
            Todo: fail gracefully if not online
            Todo: fetch by release tag
        -->
        <mkdir  dir="${grails.home}/downloads/webtest" />
        <get    dest="${grails.home}/downloads/webtest.zip" src="http://webtest.canoo.com/webtest/build.zip"
                verbose="true" usetimestamp="true"/>
        <unzip  dest="${grails.home}/downloads/webtest" src="${grails.home}/downloads/webtest.zip" overwrite="false" />

    </target>

    <target name="create-webtest" description="Create a functional testing layout" depends="init-webtest" >
        <copy todir=".">
            <fileset dir="${grails.home}/src/grails/templates/" includes="webtest/"/>
        </copy>
    </target>

    <target name="generate-webtest" description="Create a webtest for a domain class" depends="init-props" >
        <input addproperty="domain.class.name" message="Enter domain class name:" />

        <groovy>
            def domainName = properties."domain.class.name"
            properties."webtest.name" = Eval.x(domainName, properties.caps)
        </groovy>

        <copy file="${grails.home}/src/grails/templates/artifacts/WebTest.groovy"
            tofile="webtest/tests/${webtest.name}Test.groovy" />
        <replace file="webtest/tests/${webtest.name}Test.groovy"
            token="@webtest.name.caps@"
            value="${webtest.name}" />
        <replace file="webtest/tests/${webtest.name}Test.groovy"
            token="@webtest.name.lower@"
            value="${domain.class.name}" />
        <echo>Webtest created: webtest/tests/${webtest.name}Test.groovy</echo>

    </target>

    <target name="run-webtest" depends="init-props" description="Run the functional tests for a running app">
        <antcall target="run-app:impl">
            <param name="runTests" value="true"/>
        </antcall>
    </target>

    <target name="webtest-impl">
        <java classname="groovy.ui.GroovyMain" >
            <arg line="webtest/tests/TestSuite"/>
            <classpath>
                <pathelement location="webtest/tests"/>
                <fileset dir="${grails.home}/lib" includes="*.jar"/>
                <fileset dir="${grails.home}/dist" includes="*.jar"/>
                <pathelement location="${grails.home}/downloads/webtest/lib"/>
                <fileset dir="${grails.home}/downloads/webtest/lib" includes="**/*.jar"/>
            </classpath>
        </java>
    </target>


</project>