build.gradle

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: 'https://raw.github.com/evgeny-goldin/scripts/master/src/main/gradle/wrapper.gradle'


buildscript {
    repositories { maven { url 'http://evgenyg.artifactoryonline.com/evgenyg/repo/' }}
    dependencies {
        classpath 'com.github.goldin.plugins.gradle:about:0.2',
                  'com.github.goldin.plugins.gradle:duplicates:0.2'
    }
}


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' ])
    }
}


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 extraJars     = ( ! p.hasProperty( 'nj' /* no jars */ ))

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

    repositories {
        maven { url 'http://evgenyg.artifactoryonline.com/evgenyg/repo/' }
        maven { url 'http://repository.jetbrains.com/kotlin/' }
    }

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

    dependencies {
        compile     gradleApi(),
                    'org.gcontracts:gcontracts-core:1.2.10'
        testCompile 'junit:junit:4.11'
        testRuntime 'ch.qos.logback:logback-classic:1.0.9'
    }

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

    idea.module {
        downloadSources = true
        downloadJavadoc = false
    }

    /**
     * Adding sources and groovydocs
     */

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

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

    if ( extraJars )
    {
        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( ':kotlin' ) {
    dependencies {
        compile   'org.jetbrains.kotlin:kotlin-compiler:0.5.1'
        compile ( 'org.jetbrains.kotlin:kdoc:0.5.1' ){
            exclude group:  'asm'            /* Brought by gcontracts */
            exclude module: 'kotlin-runtime' /* Conflicts with 'kotlin-compiler' */
        }
    }
}


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, "[$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 [$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 )}
}