build.gradle

plugins {
    id 'org.jetbrains.kotlin.multiplatform' version '1.3.50'
    id 'jacoco'
    id 'java'
    id 'com.github.dawnwords.jacoco.badge' version '0.1.0'
    id 'io.gitlab.arturbosch.detekt' version '1.0.0-RC16'
    id 'com.diffplug.gradle.spotless' version '3.24.0'
    id "com.jfrog.bintray" version "1.8.4"
}

jacocoBadgeGenSetting {
    jacocoReportPath "$buildDir/reports/jacoco/testCommonUnitTestCoverage/testCommonUnitTestCoverage.xml"
}

jacocoTestCoverageVerification {
    violationRules {
        rule {
            limit {
                minimum = 0.95
            }
        }
    }

    def excludes = [
            '**/*Test*.*'
    ]
    def coverageSourceDirs = [
            "src/commonMain/kotlin"
    ]

    getSourceDirectories().setFrom(files(coverageSourceDirs))
    getExecutionData().setFrom(files("${project.buildDir}/jacoco/jvmTest.exec"))
    getClassDirectories().setFrom(fileTree(
            dir: "${project.buildDir}/classes/kotlin/jvm/",
            excludes: excludes
    ))
}


repositories {
    mavenCentral()
    jcenter()
    jcenter {
        url 'https://hmrc.bintray.com/releases/'
    }
    maven {
        url "https://plugins.gradle.org/m2/"
    }
}

static def getDate() {
    def date = new Date()
    def formattedDate = date.format('yyyyMMddHHmm')
    return formattedDate
}

group 'uk.gov.hmrc'
description='Multiplatform Tax Calculator library'
version=System.getenv('BITRISE_GIT_TAG') ?: ("SNAPSHOT-" + getDate() )


apply plugin: 'maven-publish'
String frameworkName = 'TaxKalculator'

kotlin {
    targets {
        final def iOSTarget = System.getenv('SDK_NAME')?.startsWith("iphoneos")    \
                             ? presets.iosArm64 : presets.iosX64

        fromPreset(iOSTarget, 'ios') {
            binaries {
                framework(frameworkName)
            }
        }
        fromPreset(presets.jvm, 'jvm')
    }

    sourceSets {
        all {
            languageSettings {
                useExperimentalAnnotation('kotlin.Experimental')
            }
        }
        def klockVersion = "1.7.5"
        commonMain {
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-stdlib-common'
                implementation "com.soywiz.korlibs.klock:klock:$klockVersion"
            }
        }
        commonTest {
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-test-common'
                implementation 'org.jetbrains.kotlin:kotlin-test-annotations-common'
            }
        }
        jvmMain {
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-stdlib'
            }
        }
        jvmTest {
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-test'
                implementation 'org.jetbrains.kotlin:kotlin-test-junit'
            }
        }
        iosMain {
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-stdlib'
            }
        }
        iosTest {}
    }
}

task iosTest {
    def device = project.findProperty("iosDevice")?.toString() ?: "iPhone 8"
    dependsOn kotlin.targets.ios.binaries.getTest('DEBUG').linkTaskName
    group = JavaBasePlugin.VERIFICATION_GROUP
    description = "Runs tests for target 'ios' on an iOS simulator"

    doLast {
        def binary = kotlin.targets.ios.binaries.getTest('DEBUG').outputFile
        exec {
            commandLine 'xcrun', 'simctl', 'spawn', device, binary.absolutePath
        }
    }
}

task packForXCode(type: Sync) {
    final File frameworkDir = new File(buildDir, "xcode-frameworks")
    final String mode = project.findProperty("XCODE_CONFIGURATION")?.toUpperCase() ?: 'DEBUG'
    final def framework = kotlin.targets.ios.binaries.getFramework(frameworkName, mode)

    inputs.property "mode", mode
    dependsOn framework.linkTask

    from { framework.outputFile.parentFile }
    into frameworkDir

    doLast {
        new File(frameworkDir, 'gradlew').with {
            text = "#!/bin/bash\nexport 'JAVA_HOME=${System.getProperty("java.home")}'\ncd '${rootProject.rootDir}'\n./gradlew \$@\n"
            setExecutable(true)
        }
    }
}
tasks.build.dependsOn packForXCode

configurations {
    compileClasspath
}

jacoco {
    toolVersion = "0.8.4"
}

detekt {
    input = files("src/commonMain/kotlin")
    config = files("detekt-config.yml")
}

// Create gradle task
task "testCommonUnitTestCoverage"(type: JacocoReport, dependsOn: "allTests") {
    group = "Reporting"
    description = "Generate Jacoco coverage reports on the common module build."

    def excludes = [
            '**/*Test*.*'
    ]
    def coverageSourceDirs = [
            "src/commonMain/kotlin"
    ]

    getSourceDirectories().setFrom(files(coverageSourceDirs))
    getExecutionData().setFrom(files("${project.buildDir}/jacoco/jvmTest.exec"))
    getClassDirectories().setFrom(fileTree(
            dir: "${project.buildDir}/classes/kotlin/jvm/",
            excludes: excludes
    ))
    reports {
        xml.enabled = true
        html.enabled = true
    }
}

task cleanBuildTestCoverage(type: GradleBuild) {
    tasks = ['clean', 'cleanAllTests', 'build','testCommonUnitTestCoverage', 'generateJacocoBadge', 'jacocoTestCoverageVerification']
}

Properties credentials = new Properties()
rootProject.file("credentials.properties").withInputStream { credentials.load(it) }

bintray {
    user = credentials.getProperty('bintray.user')
    key = credentials.getProperty('bintray.apikey')

    publications = ['jvm', 'metadata']

    publish = true
    
    pkg {
        repo = 'mobile-releases'
        name = project.name
        userOrg = 'hmrc'
        desc = project.description
        licenses = ['Apache-2.0']
        version {
            name = project.version
            released = new Date()
        }

        def license = '''\
/*
 * Copyright $YEAR HM Revenue & Customs
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
'''

        spotless {
            kotlin {
                target "**/*.kt"
                ktlint()
                licenseHeader license
            }
        }
    }
}