build.gradle

import au.id.micolous.metrodroid.LocalizeGenerator

allprojects {
    repositories {
        google()
        mavenCentral()
        maven { url "https://kotlin.bintray.com/kotlinx" }
    }
}

buildscript {
    ext {
        kotlin_version = '1.5.31'
        kotlinserial_version = '1.3.0'
        coroutines_version = '1.5.2'
        lint_version = '26.2.1'
        support_version = '31.0.0'
        android_test_version = '1.4.0'
        build_version = '31.0.0'
        android_sdk_version = 31
        android_min_version = 16
        android_gradle_version = '7.0.2'
        protobuf_version = '3.18.1'
        protobuf_gradle_version = '0.8.17'
    }
    repositories {
        google()
        mavenCentral()
    }

    dependencies {
        classpath "com.android.tools.build:gradle:$android_gradle_version"
        classpath "com.google.protobuf:protobuf-gradle-plugin:$protobuf_gradle_version"
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
        classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"
    }
}

apply plugin: 'com.android.application'
apply plugin: 'kotlin-multiplatform'
apply plugin: 'checkstyle'
apply plugin: 'kotlin-parcelize'
apply plugin: 'kotlinx-serialization'
apply plugin: 'jacoco'

jacoco {
    toolVersion = "0.8.7"
}

task jvmCliJacoco(type: JacocoReport, dependsOn: 'jvmCliTest') {

    reports {
        xml.enabled = true
        html.enabled = true
    }

    def fileFilter = ['**/R.class', '**/R$*.class', '**/BuildConfig.*', '**/Manifest*.*', '**/*Test*.*', 'android/**/*.*', 'main/au/id/micolous/metrodroid/multi/R*.class']
    def debugTree = fileTree(dir: "${buildDir}/classes/kotlin/jvmCli", excludes: fileFilter)

    sourceDirectories.from = files(["${project.projectDir}/src/jvmCommonMain/kotlin",
                                    "${project.projectDir}/src/jvmCliMain/kotlin",
                                    "${project.projectDir}/src/commonMain/kotlin"])
    classDirectories.from = files([debugTree])
    executionData(files("${buildDir}/jacoco/jvmCliTest.exec"))
}

task androidDebugUnitJacoco(type: JacocoReport, dependsOn: 'testDebugUnitTest') {

    reports {
        xml.enabled = true
        html.enabled = true
    }

    def fileFilter = ['**/R.class', '**/R$*.class', '**/BuildConfig.*', '**/Manifest*.*', '**/*Test*.*', 'android/**/*.*', 'au/id/micolous/metrodroid/multi/R*.class']
    def debugTree = fileTree(dir: "${buildDir}/tmp/kotlin-classes/debug", excludes: fileFilter)

    sourceDirectories.from = files(["${project.projectDir}/src/jvmCommonMain/kotlin",
                                    "${project.projectDir}/src/main/java",
                                    "${project.projectDir}/src/commonMain/kotlin"])
    classDirectories.from = files([debugTree])
    executionData(files("${buildDir}/outputs/unit_test_code_coverage/debugUnitTest/testDebugUnitTest.exec"))
}

def generatedLocalizeDir = new File(buildDir, "generated/source/localize")
def generatedLanguagesDir = new File(buildDir, "generated/res/localize/iOS")
def svgDir = new File(projectDir, "cardimages/svg")
def drawableDir = new File(projectDir, "cardimages/android/drawable")
def relativeDrawableHdpiDir = "cardimages/android/drawable-hdpi"
def drawableHdpiDir = new File(projectDir, relativeDrawableHdpiDir)
def stringsXmlFile = new File(projectDir, "src/main/res/values/strings.xml")
def cardAssetsDir = new File(projectDir, "native/metrodroid/metrodroid/Cards.xcassets")
def testAssetsDirs = [
        'src/commonTest/assets',
        'third_party/vpereira_bilhete/',
        'third_party/RejsekortReader/dumps/'
]

task generateLocalize {
    inputs.file stringsXmlFile
    inputs.dir drawableDir
    inputs.dir drawableHdpiDir
    outputs.dir generatedLocalizeDir
    doLast {
        LocalizeGenerator.INSTANCE.generateLocalize(generatedLocalizeDir, stringsXmlFile, [drawableDir, drawableHdpiDir])
    }
}

def iOSUnsupportedImages = [
        'barnaul',
        'beijing',
        'bilheteunicosp_card',
        'busitcard',
        'cadizcard',
        'charlie_card',
        'chc_metrocard',
        'crimea_trolley',
        'ekarta',
        'ezlink_card',
        'gautrain',
        'kazan',
        'kiev',
        'kirov',
        'komuterlink',
        'krasnodar_etk',
        'laxtap_card',
        'leap_card',
        'manly_fast_ferry_card',
        'metromoney',
        'metroq',
        'msp_goto_card',
        'myway_card',
        'nets_card',
        'omka',
        'orenburg_ekg',
        'ovchip_card',
        'oyster_card',
        'parus_school',
        'penza',
        'podorozhnik_card',
        'rejsekort',
        'ricaricami',
        'rotorua',
        'samara_etk',
        'selecta',
        'seqgo_card',
        'siticard',
        'siticard_vladimir',
        'smartrider_card',
        'strelka_card',
        'strizh',
        'suncard',
        'tartu',
        'tpe_easy_card',
        'troika_card',
        'warsaw_card',
        'yaroslavl_etk',
        'yoshkar_ola',
        'zolotayakorona'
]

task iOSImages {
    inputs.dir drawableHdpiDir
    inputs.dir svgDir
    outputs.dir cardAssetsDir
    doLast {
        fileTree(drawableHdpiDir).visit { FileVisitDetails details ->
            def name = details.file.name
            def basename = name.replaceFirst(~/\.[a-z]*$/) { _ -> "" }
            if (basename in iOSUnsupportedImages) {
                return
            }

            def imageset = new File(cardAssetsDir, basename + ".imageset")

            mkdir(imageset)

            new File(imageset, "Contents.json").text = """{
  "images" : [
    {
      "idiom" : "universal",
      "filename" : "$name",
      "scale" : "1x"
    },
    {
      "idiom" : "universal",
      "scale" : "2x"
    },
    {
      "idiom" : "universal",
      "scale" : "3x"
    }
  ],
  "info" : {
    "version" : 1,
    "author" : "xcode"
  }
}
"""
            def link = new File(imageset, name)
            delete link
            ant.symlink(resource: "../../../../../" + relativeDrawableHdpiDir + "/" + name, link: link)
        }

        // To keep the size of app low we only generate 1x scale for
        // cards
        fileTree(svgDir).visit { FileVisitDetails details ->
            def name = details.file.name
            def basename = name.replaceFirst(~/\.[a-z]*$/) { _ -> "" }
            if (basename in iOSUnsupportedImages) {
                return
            }

            def imageset = new File(cardAssetsDir, basename + ".imageset")

            mkdir(imageset)

            new File(imageset, "Contents.json").text = """{
  "images" : [
    {
      "idiom" : "universal",
      "filename" : "${basename}.png",
      "scale" : "1x"
    },
    {
      "idiom" : "universal",
      "scale" : "2x"
    },
    {
      "idiom" : "universal",
      "scale" : "3x"
    }
  ],
  "info" : {
    "version" : 1,
    "author" : "xcode"
  }
}
"""
            def render = new File(imageset, basename + ".png")
            exec {
                commandLine System.getenv('INKSCAPE') ?: "inkscape", "-z", "-e", render, "-w", "380", details.file.path
            }
        }
    }
}

preBuild.dependsOn generateLocalize

/*
check.dependsOn 'checkstyle'

task checkstyle(type: Checkstyle) {
    source 'src'
    include '** /*.java'
    exclude '** /gen/**'
    classpath = files()
}
*/

dependencies {
    implementation("androidx.appcompat:appcompat:1.3.1")
    implementation "androidx.cardview:cardview:1.0.0"
    implementation "androidx.annotation:annotation:1.3.0"
    implementation "androidx.preference:preference:1.1.1"
    implementation "com.google.protobuf:protobuf-javalite:$protobuf_version"
    implementation project(':leaflet')
    implementation project(':material-design-icons')
    implementation project(':proto')

    implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:$kotlinserial_version"
    implementation "org.jetbrains.kotlinx:kotlinx-serialization-protobuf:$kotlinserial_version"

    implementation 'com.github.bmelnychuk:atv:1.2.9'
    implementation 'androidx.constraintlayout:constraintlayout:2.1.1'
    implementation 'com.google.android.material:material:1.4.0'
    implementation "androidx.multidex:multidex:2.0.1"

    coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:1.1.5'

    androidTestUtil "androidx.test:orchestrator:$android_test_version"
    androidTestImplementation "androidx.test:rules:$android_test_version"
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
    androidTestImplementation "androidx.test.ext:junit:1.1.3"
    testImplementation 'org.robolectric:robolectric:4.7.3'

    lintChecks project(':lintchecks')
}

task copyThirdPartyNotices(type: Copy) {
    from 'third_party/'
    into 'build/assets/third_party'
    eachFile { it.path = name }
    include 'NOTICE.**.txt'
}

kotlin {
    targets {
        fromPreset(presets.android, 'android')
        fromPreset(presets.jvm, 'jvmCli') {
            compilations.all {
                tasks[compileKotlinTaskName].dependsOn += generateLocalize
                kotlinOptions {
                    jvmTarget = "9"
                }
            }
        }

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

        fromPreset(iOSTarget, 'iOS') {
            binaries {
                framework("metrolib") {
                    linkTask.dependsOn += 'generateLocalize'
                    linkTask.dependsOn += 'iOSLanguages'
                }
            }
            binaries.all {
                linkerOpts new File(project('proto').buildDir, 'libs/main/static/libmain.a').path
            }

            compilations.all {
                tasks[compileKotlinTaskName].dependsOn += 'generateLocalize'
                tasks[compileKotlinTaskName].dependsOn += 'iOSLanguages'
                tasks[compileKotlinTaskName].dependsOn += ':proto:mainStaticLibrary'
                cinterops {
                    stations {
                        defFile project.file("src/iOSMain/cinterop/stations.def")
                        includeDirs(new File(project('proto').buildDir, 'generated/source/proto/main/objc'))
                        compilerOpts '-I' + projectDir +
                                '/third_party/protobuf/objectivec', '-DTARGET_OS_OSX=0',
                                '-DTARGET_OS_MACCATALYST=0', '-DNS_FORMAT_ARGUMENT(A)=', '-D_Nullable_result=_Nullable'
                    }
                }
            }
        }
    }

    sourceSets {
        commonMain {
            dependencies {
                api "org.jetbrains.kotlinx:kotlinx-serialization-json:$kotlinserial_version"
                api "org.jetbrains.kotlinx:kotlinx-serialization-protobuf:$kotlinserial_version"
                implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.3.0")
            }

            kotlin.srcDirs += new File(generatedLocalizeDir, 'commonMain/kotlin')
        }

        commonTest {
            dependencies {
                api "org.jetbrains.kotlin:kotlin-test-common:$kotlin_version"
                api "org.jetbrains.kotlin:kotlin-test-annotations-common:$kotlin_version"
            }
        }

        androidMain {
            dependencies {
                implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:$coroutines_version"
                implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutines_version"
            }

            kotlin.srcDirs += new File(generatedLocalizeDir, 'androidMain/kotlin')
            kotlin.srcDirs += 'src/jvmCommonMain/kotlin'
        }

        iOSMain {
            dependencies {
                implementation project(':proto')
                implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:${coroutines_version}-native-mt"
            }

            kotlin.srcDirs += new File(generatedLocalizeDir, 'iOSMain/kotlin')
        }

        iOSTest {
            dependencies {
                implementation project(':proto')
            }
        }

        androidTest {
            dependencies {
                implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:$coroutines_version"
                implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutines_version"
                implementation 'org.jetbrains.kotlin:kotlin-test-junit'
                implementation project(':proto')
            }
            kotlin.srcDirs += [
                    'src/jvmCommonTest/kotlin'
            ]
        }


        jvmCliTest {
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-test-junit'
            }

            resources.srcDirs += [
                    'src/commonTest/assets',
                    'third_party/vpereira_bilhete/',
                    'third_party/RejsekortReader/dumps/'
            ]
            kotlin.srcDirs += [
                    'src/jvmCommonTest/kotlin'
            ]
        }

        jvmCliMain {
            dependencies {
                implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutines_version"
                implementation "com.google.protobuf:protobuf-javalite:$protobuf_version"
                implementation 'com.github.ajalt.clikt:clikt:3.3.0'
                implementation group: 'xmlpull', name: 'xmlpull', version: '1.1.3.4a'
                implementation project(':proto')
                implementation 'au.id.micolous:kotlin-pcsc'
                implementation group: 'net.sf.kxml', name: 'kxml2', version: '2.3.0'
            }
            kotlin.srcDirs += new File(generatedLocalizeDir, 'jvmCliMain/kotlin')
            resources.srcDirs += new File("$projectDir/mdst")
            resources.srcDirs += new File("$projectDir/src/commonMain/assets")
            resources.srcDirs += new File("$projectDir/src/main/res")
            resources.srcDirs += ["$buildDir/assets"]
            kotlin.srcDirs += 'src/jvmCommonMain/kotlin'
            preBuild.dependsOn copyThirdPartyNotices
        }
    }
}

tasks['jvmCliProcessResources'].dependsOn copyThirdPartyNotices

def commonLanguageList = [
        // Update this whenever new language translations become available in Weblate.
        // Languages we support
        // Also add the language in XCode
        'en',
        'en-rAU', 'en-rCA', 'en-rGB', 'en-rIE', 'en-rIN', 'en-rNZ', 'en-rUS',
        'de',
        'el',
        'es',
        'fi',
        'fr',
        'he',
        'id',
        'it',
        'ja',
        'kab',
        'nb-rNO',
        'nl',
        'pt-rBR',
        'ru',
        'tr',
        'zh-rCN'
]

def iOSLanguageList = commonLanguageList

def androidLanguageList = iOSLanguageList + [
        // We omit languages without real translations on iOS
        'ga',
        'mi',
        'ms',
        'zh-rHK',
        'zh-rSG',
        'zh-rTW',

        // obsolete identifier
        'iw',
        'in'
]

static def mapAndroidLanguageToIOS(String alang) {
    if (alang == "nb-rNO")
        return "nb"
    if (alang == "zh-rCN")
        return "zh-Hans"
    return alang.replaceAll(/^([a-z]*)-r([A-Z]*)$/) { all, lang, region -> "$lang-$region" }
}

def langSources(String alang) {
    def baseLang = alang.replaceAll(/^([a-z]*)-r([A-Z]*)$/) { all, lang, region -> "$lang" }
    if (baseLang == "en")
        return [new File(projectDir, "src/main/res/values-" + alang + "/strings.xml"),
                new File(projectDir, "src/main/res/values-" + baseLang + "/strings.xml")]
    return [new File(projectDir, "src/main/res/values-" + alang + "/strings.xml")]
}

task iOSLanguages {
    inputs.file stringsXmlFile
    outputs.dir generatedLanguagesDir
    doLast {
        for (lang in iOSLanguageList) {
            LocalizeGenerator.INSTANCE.generateAppleStringsFile(
                    new File(generatedLanguagesDir, mapAndroidLanguageToIOS(lang) + '.lproj/Metrolib.strings'),
                    langSources(lang),
                    lang
            )
        }
    }
}

task iOSMappedLanguages {
    doLast {
        for (lang in iOSLanguageList) {
            LocalizeGenerator.INSTANCE.generateMappedAppleStringsFile(
                    new File(projectDir, 'native/metrodroid/metrodroid/' + mapAndroidLanguageToIOS(lang) + '.lproj/Main.strings'),
                    langSources(lang),
                    new File(projectDir, 'native/metrodroid/metrodroid/MainMap.txt')
            )
            LocalizeGenerator.INSTANCE.generateMappedAppleStringsFile(
                    new File(projectDir, 'native/metrodroid/metrodroid/metrodroid/' + mapAndroidLanguageToIOS(lang) + '.lproj/InfoPlist.strings'),
                    langSources(lang),
                    new File(projectDir, 'native/metrodroid/metrodroid/InfoPlistMap.txt')
            )
            LocalizeGenerator.INSTANCE.generateMappedAppleStringsFile(
                    new File(projectDir, 'native/metrodroid/Settings.bundle/' + mapAndroidLanguageToIOS(lang) + '.lproj/Root.strings'),
                    langSources(lang),
                    new File(projectDir, 'native/metrodroid/SettingsMap.txt')
            )
        }
    }
}

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("metrolib", mode)

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

    from framework.outputFile
    into new File(frameworkDir, "metrolib.framework")

    from generatedLanguagesDir
    into new File(frameworkDir, "metrolib.framework")
}

tasks.build.dependsOn packForXCode

task copyTestAssetsIOS {
    testAssetsDirs.each {
        inputs.dir new File(projectDir, it)
    }
    inputs.dir new File(projectDir, "mdst")
    outputs.dir kotlin.targets.iOS.binaries.getTest("DEBUG").outputFile.getParentFile()
    inputs.dir new File(projectDir, "src/commonMain/assets")
    outputs.dir kotlin.targets.iOS.binaries.getTest("DEBUG").outputFile.getParentFile()
    dependsOn iOSLanguages
    doLast {
        def outBase = kotlin.targets.iOS.binaries.getTest("DEBUG").outputFile.getParentFile()
        for (lang in iOSLanguageList) {
            def lproj = mapAndroidLanguageToIOS(lang) + '.lproj'
            def target = new File(outBase, lproj)
            delete target
            ant.symlink(resource: "../../../generated/res/localize/iOS/$lproj", link: target)
        }
        testAssetsDirs.each { relativeDir ->
            new File(projectDir, relativeDir).list().each { subDir ->
                def link = new File(outBase, subDir)
                delete link
                ant.symlink(resource: "../../../../" + relativeDir + "/" + subDir, link: link)
            }
        }

        def link = new File(outBase, "mdst")
        delete link
        ant.symlink(resource: "../../../../mdst", link: link)
    }
}


linkDebugTestIOS.dependsOn 'copyTestAssetsIOS'

task iOSSimulatorTest {
    def device = project.findProperty("iosDevice")?.toString() ?: "iPhone 8"
    dependsOn 'linkDebugTestIOS'
    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
        }
    }
}

android {
    compileSdkVersion android_sdk_version
    buildToolsVersion build_version

    defaultConfig {
        minSdkVersion android_min_version
        targetSdkVersion android_sdk_version
        testApplicationId "au.id.micolous.farebot.test"
        versionCode "git -C ${projectDir} rev-list --count HEAD".execute().text.trim().toInteger()
        versionName "git -C ${projectDir} describe --always --tags --dirty".execute().text.trim().replaceAll("^v", "")

        resConfigs(androidLanguageList)
        buildConfigField "String[]", "AVAILABLE_TRANSLATIONS", "new String[]{\"" + androidLanguageList.join("\", \"") + "\"}"
        vectorDrawables {
            useSupportLibrary = true
            generatedDensities 'ldpi', 'mdpi', 'hdpi'
        }
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"

        // The following argument makes the Android Test Orchestrator run its
        // "pm clear" command after each test invocation. This command ensures
        // that the app's state is completely cleared between tests.
        testInstrumentationRunnerArguments clearPackageData: 'true'

        multiDexEnabled true
    }

    buildTypes {
        debug {
            pseudoLocalesEnabled true
            buildConfigField "String[]", "AVAILABLE_TRANSLATIONS", "new String[]{\"" + androidLanguageList.join("\", \"") + "\", \"en-rXA\", \"ar-rXB\"}"
            testCoverageEnabled true
            debuggable true
        }
        dev.initWith(buildTypes.debug)
        dev {
            applicationIdSuffix '.dev'
            minifyEnabled true
            shrinkResources true
            proguardFiles getDefaultProguardFile('proguard-android.txt'),
                    'proguard.cfg'
            matchingFallbacks = ['debug']
        }
        release {
            minifyEnabled true
            shrinkResources true
            proguardFiles getDefaultProguardFile('proguard-android.txt'),
                    'proguard.cfg'
        }
    }

    applicationVariants.all { variant ->
        if (variant.buildType.name == "debug") {
            variant.mergedFlavor.resourceConfigurations.add("en-rXA")
            variant.mergedFlavor.resourceConfigurations.add("ar-rXB")
        }
    }

    preBuild.dependsOn copyThirdPartyNotices

    sourceSets {
        androidTest.assets.srcDirs += testAssetsDirs
        androidTest.java.srcDirs += ['src/jvmCommonTest/kotlin']
        androidTest.java.srcDirs += ['src/androidCommonTest/kotlin']
        main.assets.srcDirs += ['build/assets', 'mdst', 'src/commonMain/assets']
        main.res.srcDirs += ['cardimages/android']
        test.java.srcDirs += ['src/androidUnitTest/kotlin']
        test.java.srcDirs += ['src/androidCommonTest/kotlin']
        test.resources.srcDirs += testAssetsDirs
    }

    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
        coreLibraryDesugaringEnabled true
    }

    kotlinOptions {
        jvmTarget = "1.8"
    }

    packagingOptions {
        exclude 'META-INF/LICENSE.txt'
        exclude 'META-INF/NOTICE.txt'
        exclude 'META-INF/kotlinx-io.kotlin_module'
        exclude 'META-INF/atomicfu.kotlin_module'
        exclude 'META-INF/main.kotlin_module'
        exclude 'META-INF/kotlinx-serialization-runtime.kotlin_module'
    }

    lintOptions {
        abortOnError(project.hasProperty('LINT_FATAL'))
        warningsAsErrors(project.hasProperty('LINT_FATAL'))
        disable 'MissingTranslation'
        // Lint doesn't understand our multiplatform setup
        disable 'UnusedResources'
        // We make a link from valuen-en to values and hence
        // all untranslatable strings are considered as "translated"
        disable 'Untranslatable'
        // We link between id<->in and he <-> iw so usage of in/he
        // is of no issue
        disable 'LocaleFolder'
        // We use vector images for card images mainly to decrease size
        // and improve the look
        disable 'VectorPath'
        disable 'VectorRaster'
        // We don't want translations to make lint fail
        disable 'ImpliedQuantity'
        disable 'Typos'
        disable 'TypographyDashes'
        // Disable following temporarily until we get them in order
        disable 'ObsoleteLintCustomCheck'
        disable 'IconDensities'
        disable 'IconMissingDensityFolder'
        disable 'StaticFieldLeak'
        disable 'AppLinkUrlError'
        disable 'RelativeOverlap'
    }

    testOptions {
        unitTests {
            includeAndroidResources = true
            all {
                jacoco {
                    includeNoLocationClasses = true
                    excludes = ['jdk.internal.*']
                }
            }
        }
    }

    // Long timeouts needed for slow environments (like Travis CI)
    adbOptions {
        timeOutInMs 10 * 60 * 1000 // 10 minutes
    }
}

kotlin.sourceSets.all {
    languageSettings {
        optIn('kotlin.ExperimentalUnsignedTypes')
        optIn('kotlin.Experimental')
    }
}

repositories {
    mavenCentral()
}

// workaround for https://youtrack.jetbrains.com/issue/KT-27170
configurations {
    compileClasspath
}

// Activate reproducible archives
tasks.withType(AbstractArchiveTask) {
    preserveFileTimestamps = false
    reproducibleFileOrder = true
}