build.gradle

ext {
    airshipProperties = new Properties()
    airshipProperties.load(new FileInputStream("$projectDir/airship.properties"))
    toolsDir = new File("$projectDir/.tools")
    if ( !toolsDir.exists() ) {
        toolsDir.mkdirs()
    }
    rootDir = new File("$projectDir")
    nugetExe = new File("$toolsDir/nuget.exe")
    if (!nugetExe.exists()) {
        new URL('https://dist.nuget.org/win-x86-commandline/latest/nuget.exe').withInputStream{
            i -> nugetExe.withOutputStream{ it << i }
        }
    }
    msbuild = "/Library/Frameworks/Mono.framework/Commands/msbuild"
}

// Build nuget pkgs -- can pass in parameters (nuspec files) to specify which
// nupkg files to build
task pkg {
    dependsOn 'build'
    doLast() {
        def nuspecs = []
        if (project.hasProperty('nuspec')) {
            nuspecs = nuspec.split(',')
        } else {
            nuspecs = [
                "Airship.Android.Core.nuspec",
                "Airship.Android.ADM.nuspec",
                "Airship.Android.FCM.nuspec",
                // "Airship.Android.FeatureFlag.nuspec",
                "Airship.Android.MessageCenter.nuspec",
                "Airship.Android.Layout.nuspec",
                "Airship.Android.Automation.nuspec",
                "Airship.Android.LiveUpdate.nuspec",
                "Airship.Android.PreferenceCenter.nuspec",
                "Airship.iOS.Basement.nuspec",
                "Airship.iOS.Core.nuspec",
                "Airship.iOS.Automation.nuspec",
                "Airship.iOS.MessageCenter.nuspec",
                "Airship.iOS.PreferenceCenter.nuspec",
                "Airship.iOS.NotificationContentExtension.nuspec",
                "Airship.iOS.NotificationServiceExtension.nuspec",
                "Airship.iOS.nuspec",
                "Airship.NETStandard.nuspec",
            ]
        }

        for (nuspec in nuspecs) {
            exec {
                commandLine "mono", "${nugetExe}", "pack", "$nuspec", "-OutputDirectory", "$buildDir"
            }
        }
    }
}

// Create local nuget feed
task createLocalFeed {
    doLast() {
        // add doesn't have a "-force" option, so first remove all the nuget packages from the local feed
        File localNugetFeed = file("${rootDir}/local-nuget-feed")
        localNugetFeed.deleteDir()

        // get all the nuget packages from the build directory
        def nupkgs = buildDir.listFiles(new FilenameFilter() {
            public boolean accept(File dir, String name) {
                return name.toLowerCase().endsWith(".nupkg");
            }
        })

        // add the packages to the local nuget feed
        nupkgs.each { nupkg ->
            // add the package to the local nuget feed
            exec {
                commandLine "mono", "${nugetExe}", "add", "$nupkg", "-source", "$localNugetFeed"
            }
        }

        // clear the local nuget cache (so new packages with unchanged versions are used)
        exec {
            commandLine "mono", "${nugetExe}", "locals", "all", "-clear"
        }

    }
}
createLocalFeed.dependsOn('pkg')

// Sync the nuspec and shared assembly versions with the version declared in the airship.properties file.
task syncRootVersion {
    doLast() {

        def androidNugetVersion = airshipProperties.androidVersion
        if (airshipProperties['androidPackageVersion']) {
            androidNugetVersion = "${airshipProperties.androidVersion}.${airshipProperties.androidPackageVersion}"
        }

        def iosNugetVersion = airshipProperties.iosNugetVersion
        if (airshipProperties['iosPackageVersion']) {
            iosNugetVersion = "${airshipProperties.iosNugetVersion}.${airshipProperties.iosPackageVersion}"
        }

        // Handle Android nuspec versions
        ant.replaceregexp(
            match: "<version>.*</version>",
            replace: "<version>$androidNugetVersion</version>"
        ) {
            fileset(dir: "$projectDir", includes: "Airship.Android*.nuspec")
        }

        // Handle iOS nuspec versions
        ant.replaceregexp(
            match: "<version>.*</version>",
            replace: "<version>$iosNugetVersion</version>"
        ) {
            fileset(dir: "$projectDir", includes: "Airship.iOS*.nuspec")
        }

        // Handle .NET Standard versions
        ant.replaceregexp(
            file: "$projectDir/Airship.NETStandard.nuspec",
            match: "<version>.*</version>",
            replace: "<version>$airshipProperties.crossPlatformVersion</version>",
            flags: "g"
        )

        // handle airship.android.core dependencies
        ant.replaceregexp(
            match: "<dependency id=\"airship.android(.*)\" version=\".*\"/>",
            replace: "<dependency id=\"airship.android\\1\" version=\"$androidNugetVersion\"/>",
            flags: "g"
        ) {
            fileset(dir: "$projectDir", includes: "Airship*.nuspec")
        }

        // handle airship.ios dependencies
        ant.replaceregexp(
            match: "<dependency id=\"airship.ios(.*)\" version=\".*\"/>",
            replace: "<dependency id=\"airship.ios\\1\" version=\"$iosNugetVersion\"/>",
            flags: "g"
        ) {
            fileset(dir: "$projectDir", includes: "Airship*.nuspec")
        }

        // Shared assembly info
        ant.replaceregexp(
            file: "$projectDir/src/SharedAssemblyInfo.CrossPlatform.cs",
            match: "AssemblyVersion (.*)]",
            replace: "AssemblyVersion (\"$airshipProperties.crossPlatformVersion\")]"
        )

        ant.replaceregexp(
            file: "$projectDir/src/SharedAssemblyInfo.Android.cs",
            match: "AssemblyVersion (.*)]",
            replace: "AssemblyVersion (\"$airshipProperties.androidVersion\")]"
        )

        ant.replaceregexp(
            file: "$projectDir/src/SharedAssemblyInfo.iOS.cs",
            match: "AssemblyVersion (.*)]",
            replace: "AssemblyVersion (\"$airshipProperties.iosNugetVersion\")]"
        )

        ant.replaceregexp(
            file: "$projectDir/src/SharedAssemblyInfo.Common.cs",
            match: "UACrossPlatformVersion (.*)]",
            replace: "UACrossPlatformVersion (\"$airshipProperties.crossPlatformVersion\")]"
        )
    }
}

// Sync subproject versions with the version declared in the airship.properties file.
task syncVersion
syncVersion.mustRunAfter('clean')
syncVersion.dependsOn('syncRootVersion')
syncVersion.dependsOn(':src:AirshipBindings.Android.ADM:syncVersion',
    ':src:AirshipBindings.Android.ADM:syncVersion',
    ':src:AirshipBindings.Android.Core:syncVersion',
    ':src:AirshipBindings.Android.FCM:syncVersion',
    ':src:AirshipBindings.Android.FeatureFlag:syncVersion',
    ':src:AirshipBindings.Android.MessageCenter:syncVersion',
    ':src:AirshipBindings.Android.Automation:syncVersion',
    ':src:AirshipBindings.Android.Layout:syncVersion',
    ':src:AirshipBindings.Android.LiveUpdate:syncVersion',
    ':src:AirshipBindings.Android.PreferenceCenter:syncVersion',
    ':src:AirshipBindings.iOS.common:syncVersion',
 )

class PublishTask extends DefaultTask {
    @InputDirectory
    @Optional
    def File nupkgDir = getProject().buildDir

    @Input
    @Optional
    def File nugetExec = getProject().nugetExe

    @Input
    def String nugetRepoURL

    @Input
    def String nugetApiKey

    @TaskAction
    def publish() {
        // get all the nuget packages from the build directory
        def nupkgs = nupkgDir.listFiles(new FilenameFilter() {
            public boolean accept(File dir, String name) {
                return name.toLowerCase().endsWith(".nupkg");
            }
        })

        // publish the packages to nuget
        nupkgs.each { nupkg ->
            // publish the package
            getProject().exec {
                ignoreExitValue true
                commandLine "mono", "${nugetExec}", "push", "$nupkg", "-source", "${nugetRepoURL}", "-apikey", "${nugetApiKey}"
            }
        }
    }
}

task publishToStaging(type:PublishTask) {
    nugetRepoURL = "https://int.nugettest.org/api/v2/package"
    nugetApiKey = "$System.env.NUGET_STAGING_API_KEY"
}
publishToStaging.dependsOn('pkg')

task publishToProduction(type:PublishTask) {
    nugetRepoURL = "https://www.nuget.org/api/v2/package"
    nugetApiKey = "$System.env.NUGET_PRODUCTION_API_KEY"
}
publishToProduction.dependsOn('pkg')

//--- GLOBAL TASKS ---//

// Clean all
task clean(type: Delete) {
    doLast() {
        project.delete(files("$buildDir"))
    }
}

clean.dependsOn(':src:AirshipBindings.Android.ADM:clean',
    ':src:AirshipBindings.Android.ADM:clean',
    ':src:AirshipBindings.Android.Core:clean',
    ':src:AirshipBindings.Android.FCM:clean',
    ':src:AirshipBindings.Android.FeatureFlag:clean',
    ':src:AirshipBindings.Android.MessageCenter:clean',
    ':src:AirshipBindings.Android.Automation:clean',
    ':src:AirshipBindings.Android.Layout:clean',
    ':src:AirshipBindings.Android.LiveUpdate:clean',
    ':src:AirshipBindings.Android.PreferenceCenter:clean',
    ':src:AirshipBindings.iOS.common:clean',
 )

task preBuild() {
  doFirst() {
      mkdir project.buildDir
  }
}

// Build the plugin
task build()
build.mustRunAfter('clean')
build.dependsOn('preBuild')
build.dependsOn('syncVersion')
build.dependsOn(':docs:build',
    ':src:AirshipBindings.Android.ADM:build',
    ':src:AirshipBindings.Android.Core:build',
    ':src:AirshipBindings.Android.FCM:build',
    ':src:AirshipBindings.Android.FeatureFlag:build',
    ':src:AirshipBindings.Android.MessageCenter:build',
    ':src:AirshipBindings.Android.Automation:build',
    ':src:AirshipBindings.Android.Layout:build',
    ':src:AirshipBindings.Android.LiveUpdate:build',
    ':src:AirshipBindings.Android.PreferenceCenter:build',
    ':src:AirshipBindings.NETStandard:build',
    ':src:AirshipBindings.iOS.Basement:build',
    ':src:AirshipBindings.iOS.Core:build',
    ':src:AirshipBindings.iOS.Automation:build',
    ':src:AirshipBindings.iOS.MessageCenter:build',
    ':src:AirshipBindings.iOS.PreferenceCenter:build',
    ':src:AirshipBindings.iOS.NotificationContentExtension:build',
    ':src:AirshipBindings.iOS.NotificationServiceExtension:build' )

task getVersion() {
    doLast {
        println airshipProperties.crossPlatformVersion
    }
}