apply plugin: "sonar-runner"
ant.property(file: System.getProperty('user.home') + "/.ssdt/sonar.properties")

if (!gradle.environment.containsKey('coverage')) {
    gradle.environment.put('coverage', false)
} else {
    gradle.environment.put('coverage', gradle.environment.coverage.toBoolean())
}

println "metrics: coverage enabled: ${gradle.environment.coverage}"
buildscript {
    repositories {
        maven { url 'http://repos.ssdt.nwoca.org/artifactory/gradle-plugins' }
        maven { url 'http://repos.ssdt.nwoca.org/artifactory/repo' }
    }
    dependencies {
        classpath 'me.davesmith:jaranalyzerplugin:0.2.0-SNAPSHOT'
    }
}


apply plugin: me.davesmith.gradle.plugins.jaranalyzer.JarAnalyzerPlugin

jaranalyzer {
    dot = true
    packageFilter += 'org.slf4j*'
    packageFilter += 'groovyx.*'
}


sonarRunner {
    sonarProperties {
        property "sonar.host.url", "http://sonar.ssdt-ohio.org/"
        property "sonar.jdbc.url", ant.properties['sonar.jdbc.url']
        property "sonar.jdbc.driverClassName", ant.properties['sonar.jdbc.driverClassName']
        property "sonar.jdbc.username", ant.properties['sonar.jdbc.username']
        property "sonar.jdbc.password", ant.properties['sonar.jdbc.password']
        property "sonar.build-stability.url", "http://bamboo.ssdt-ohio.org/browse/${gradle.bambooPlan}"
        property "sonar.scm.url", "scm:hg:${gradle.hgRepositoryUrl}"
    }
}

if (gradle.environment.coverage) {

    configurations {
        jacocoAntRoot
    }
    dependencies {
        jacocoAntRoot 'org.jacoco:org.jacoco.ant:0.6.2.201302030002'
    }

    task fullCoverageReport << {
        ant {
            taskdef(name: 'jacocoreport', classname: 'org.jacoco.ant.ReportTask', classpath: configurations.jacocoAntRoot.asPath)

            mkdir dir: "${buildDir.path}/reports/coverage"

            jacocoreport {
                executiondata {
                    fileset(dir: "${buildDir.path}/coverage-results") {
                        include name: '*.jacoco.exec'
                    }
                }

                structure(name: project.name) {

                    classfiles {
                        subprojects.each { project ->
                            fileset dir: project.sourceSets.main.output.classesDir
                        }
                    }
                    sourcefiles(encoding: 'CP1252') {
                        subprojects.each { project ->
                            project.sourceSets.main.allGroovy.srcDirs.findAll { file(it).exists() } each {
                                fileset dir: "$it"
                            }
                        }
                    }
                }

                xml destfile: "${buildDir.path}/reports/coverage/jacoco.xml"
                html destdir: "${buildDir.path}/reports/coverage"
            }
        }
    }

    fullCoverageReport.dependsOn {
        subprojects.collect { project ->
            project.copyCoverageData.path
        }
    }

}

subprojects {
    afterEvaluate { project ->

        def groovyProject = project.plugins.hasPlugin('groovy')
        def javaProject = project.plugins.hasPlugin('java')

        if (gradle.environment.coverage && groovyProject) {
            logger.info "coverage analysis enabled"
            project.apply plugin: 'jacoco'

            project.jacoco {
                toolVersion = "0.6.3.201306030806"
            }

            project.test {
                jacoco {
                    enabled = true
                }
            }
            project.jacocoTestReport {
                if (groovyProject) {
                    sourceDirectories = files(sourceSets.main.allGroovy.srcDirs)
                    classDirectories = files(project.sourceSets.main.output.classesDir)
                }
                reports {
                    xml.enabled true
                    csv.enabled false
                    html.enabled true
                }
            }

            task coverageReport {
                dependsOn jacocoTestReport
            }

            task copyCoverageData(dependsOn: test, type: Copy) {
                from project.test.jacoco.destPath
                into "${rootProject.buildDir.path}/coverage-results"
                include 'test.exec'
                rename 'test.exec', "${project.name}.jacoco.exec"
            }

        }

        sonarRunner {
            sonarProperties {
                property "sonar.language", groovyProject ? 'grvy' : 'java'
                if (gradle.environment.coverage) {
                    property "sonar.java.coveragePlugin", "jacoco"
                    property "sonar.jacoco.reportPath", project.test.jacoco.destPath
                }
                property "sonar.build-stability.url", "http://bamboo.ssdt-ohio.org/browse/${gradle.bambooPlan}"
                property "sonar.scm.url", "scm:hg:${gradle.hgRepositoryUrl}"
            }
        }
				
    }
}



allprojects {
    afterEvaluate { project ->	
		project.getTasksByName('sonarRunner',false).each { it.enabled = gradle.branchStream == 'develop' }
	}	
}