build.gradle

import java.text.SimpleDateFormat

apply plugin: 'idea'


defaultTasks 'duplicates', 'clean', 'codenarc', 'build', 'install'


ext.codenarcRuleSetFiles = [ "$rootDir/codenarc.groovy" ]
ext.codenarcExtensions   = [ '**/*.groovy' ]
ext.codenarcSources      = project.subprojects.collect{ Project p -> [ "${ p.projectDir.name }/src/main/groovy",
                                                                       "${ p.projectDir.name }/src/test/groovy" ]}.flatten()

apply from: 'file:codenarc/CodeNarc.gradle'
apply from: 'file:wrapper.gradle'


buildscript {
    repositories { jcenter() }
    dependencies {
        classpath 'com.github.goldin.plugins.gradle:about:0.3.1',
                  'com.github.goldin.plugins.gradle:duplicates:0.3.1'
    }
}


allprojects {
    apply plugin: 'groovy'

    repositories { jcenter() }
    dependencies {
        compile     gradleApi(),
                    'org.gcontracts:gcontracts-core:1.2.12',
                    'org.codehaus.gpars:gpars:1.1.0',
                    'com.fasterxml.jackson.core:jackson-databind:2.2.3'
        testCompile 'junit:junit:4.11'
        testRuntime 'ch.qos.logback:logback-classic:1.0.13'
    }
}


idea.project {
    jdkName = '1.7'
    ipr.withXml { provider -> provider.node.component.find { it.@name == 'VcsDirectoryMappings' }.mapping.@vcs = 'Git' }
}


idea.module {
    excludeDirs += file( 'out' )
    iml.withXml {
        provider ->
        provider.node.component.first().appendNode( 'orderEntry', [ type : 'library', name : 'Groovy', level: 'application' ])
    }
}


task groovydocAll ( type: org.gradle.api.tasks.javadoc.Groovydoc ) {

    final groovydocDir = System.getProperty( 'groovydocDir', 'build/groovydoc' )
    final d            = new Date()
    final time         = new SimpleDateFormat( "HH:mm '(GMT'Z')'", new Locale( 'en' )).format( d )
    final date         = new SimpleDateFormat( 'MMMM dd, yyyy',    new Locale( 'en' )).format( d )

    /**
     * http://www.gradle.org/docs/current/dsl/org.gradle.api.tasks.javadoc.Groovydoc.html
     */

    subprojects*.name.each{ source( "$it/src/main/groovy" ) }

    link 'http://www.gradle.org/docs/current/javadoc/',  'org.gradle.'
    link 'http://evgeny-goldin.org/javadoc/gcontracts/', 'org.gcontracts.'
    link 'http://docs.oracle.com/javase/7/docs/api/',    'java.'
    link 'http://evgeny-goldin.org/javadoc/spock/',      'spock.'

    docTitle            = 'Gradle Plugins ' + project.version
    classpath           = configurations.compile + project( ':common' ).configurations.compile
    groovyClasspath     = classpath // http://issues.gradle.org/browse/GRADLE-1391
    use                 = true
    destinationDir      = file ( groovydocDir + ( project.version.contains( '-SNAPSHOT' ) ? '' : '/' + project.version ))
    header              = '<a href="http://evgeny-goldin.com/wiki/Gradle_Plugins">evgeny-goldin.com/wiki/Gradle_Plugins</a>'
    footer              = """
                          <a href="http://evgeny-goldin.com/">Evgeny Goldin</a>. GrovyDoc generated at $time on $date.
                          <script type="text/javascript">
                              var _gaq = _gaq || [];
                              _gaq.push(['_setAccount', 'UA-7925869-2']);
                              _gaq.push(['_setDomainName', 'none']);
                              _gaq.push(['_setAllowLinker', true]);
                              _gaq.push(['_trackPageview']);
                              (function() {
                                var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
                                ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
                                var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
                              })();
                          </script>""".stripIndent()

    doLast { logger.warn( "Done, open file:${ destinationDir.canonicalPath }/index.html" ) }
}


subprojects {

    Project p ->

    apply plugin: 'groovy'
    apply plugin: 'maven'
    apply plugin: 'idea'
    apply plugin: 'about'
    apply plugin: 'duplicates'

    sourceCompatibility = 1.6
    group               = 'com.github.goldin.plugins.gradle'
    final extraFiles    = ( ! p.hasProperty( 'nef' /* no extra files */ ))

    clean { delete( "$rootDir/out", "$rootDir/build" ) }

    about        { includeDependencies = [ 'compile', 'runtime' ]
                   prefix              = '/' }
    duplicates   { configurations      = [ 'compile', 'runtime' ]
                   verbose             = true }

    idea.module {
        downloadSources = true
        downloadJavadoc = false
    }

    if ( extraFiles ) {
        jar {
            dependsOn 'about', 'createPom'
            from new File(( File ) project.rootProject.projectDir, 'license.txt' )
        }
    }

    /**
     * Adding sources and groovydocs
     */

    task sourcesJar( type: Jar, dependsOn: classes ) {
        onlyIf { extraFiles }
        dependsOn 'about'
        classifier = 'sources'
        from sourceSets.main.allSource
        from files( "${ project.rootProject.projectDir }/license.txt" )
    }

    task groovydocJar( type: Jar, dependsOn: groovydoc ) {
        onlyIf { extraFiles }
        dependsOn 'about'
        classifier = 'javadoc'
        from groovydoc.destinationDir
        from files( "${ project.rootProject.projectDir }/license.txt" )
    }

    if ( extraFiles )
    {
        artifacts {
             archives sourcesJar
             archives groovydocJar
        }
    }

    task createPom << {
        pom {
            project {
                name          'Gradle Plugins'
                packaging     'jar'
                description   'Gradle Plugins'
                url           'http://evgeny-goldin.com/wiki/Gradle_Plugins'
                inceptionYear '2010'

                scm {
                    url                 'git@github.com:evgeny-goldin/gradle-plugins.git'
                    connection          'scm:git:git@github.com:evgeny-goldin/gradle-plugins.git'
                    developerConnection 'scm:git:git@github.com:evgeny-goldin/gradle-plugins.git'
                }

                licenses { license { name 'Apache License'; distribution 'repo' }}

                developers {
                    developer {
                        id    'evgenyg'
                        name  'Evgeny Goldin'
                        email 'evgenyg@gmail.com'
                        url   'http://evgeny-goldin.com'
                        roles { role 'Developer' }
                        timezone '+1'
                    }
                }
            }
        }.writeTo( "$buildDir/pom.xml" )
    }
}

project( ':common' ) {
    Project p ->
    p.dependencies { compile ( 'org.spockframework:spock-core:0.7-groovy-1.8' ) {
        exclude group: 'junit'
        exclude group: 'org.codehaus.groovy'
    }}
}


subprojects.findAll{ Project p -> p.name != 'common' }.each {
    Project p ->

    p.dependencies { compile project( ':common' )}

    p.processResources << {
        Copy processResourcesTask ->
        final gradleProperties = new File( processResourcesTask.destinationDir, "META-INF/gradle-plugins/${ p.name }.properties" )
        updatePropertiesFile( gradleProperties,
                              validatePropertiesFile( p, gradleProperties ),
                              [ group: p.group, name: p.name, version : p.version ])
    }
}


project( ':teamcity' ) {
    idea.module {
        excludeDirs += file( 'deploy-teamcity-artifacts/.gradle' )
        excludeDirs += file( 'deploy-teamcity-artifacts/build'   )
    }
}


private Properties validatePropertiesFile( Project p, File gradleProperties )
{
    assert gradleProperties
    assert gradleProperties.file, "Properties file [$gradleProperties.canonicalPath] is not available"

    final properties = new Properties()

    gradleProperties.withReader { properties.load( it )}

    final String implementationClass = properties[ 'implementation-class' ]
    assert implementationClass, "Gradle properties [$gradleProperties.canonicalPath] contain no 'implementation-class' property"

    final classFile = new File(( File ) p.compileGroovy.destinationDir,
                               implementationClass.replace( '.', '/' ) + '.class' )
    assert classFile.file, "File [$classFile.canonicalPath] referenced by [$implementationClass] " +
                           "in properties file [$gradleProperties.canonicalPath] is not available"
    properties
}


private void updatePropertiesFile ( File gradleProperties, Properties properties, Map<String, ?> newProperties )
{
    assert gradleProperties && gradleProperties.file
    assert properties       && newProperties

    final propertiesNames = properties.keySet()

    for ( String newProperty in newProperties.keySet())
    {
        assert ( ! ( newProperty in (( Set<String> ) propertiesNames ))), \
               "Property [$newProperty] already exists in $properties"

        properties[ newProperty ] = newProperties[ newProperty ]
    }

    gradleProperties.withWriter { properties.store( it, null )}
}