build.gradle

///////////////////////////////////////////////////
//                                               //
//             Dependency Details                //
//                                               //
///////////////////////////////////////////////////

buildscript {
    repositories {
        maven {
            url "https://artifactory.siren.io/artifactory/m2/"
        }
    }
}

plugins {
    id "base"
    id "idea"
    id "nebula.node" version "1.3.1"
    id "nebula.gulp" version "1.3.1"
    id "nebula.grunt" version "1.3.1"
}

apply from: "$rootDir/gradle/utils/repository.gradle"
apply from: "$rootDir/gradle/utils/loadPackageJson.gradle"

// This disables publication of gradle metadata to the artifactory
// The metadata is published as SHA-512 which is unsupported and we don't need it anyway
// https://docs.gradle.org/6.0.1/userguide/publishing_gradle_module_metadata.html#sub:disabling-gmm-publication
tasks.withType(GenerateModuleMetadata) {
    enabled = false
}

def packageJson = loadPackageJson()

///////////////////////////////////////////////////
//                                               //
//               Project Details                 //
//                                               //
///////////////////////////////////////////////////

group = 'solutions.siren'
version project.hasProperty('customVersion') && customVersion ? customVersion : packageJson.version
def investigateVersion = (project.hasProperty('customInvestigateVersion') && project.customInvestigateVersion?.trim()) ? customInvestigateVersion : version


///////////////////////////////////////////////////
//                                               //
//                Install Kibi                   //
//                                               //
///////////////////////////////////////////////////

/**
 * Define the kibi source artifact dependency
 */
configurations {
    kibi
}

dependencies {
    kibi "solutions.siren:investigate-core:${investigateVersion}:sources@zip"
}

/**
 * Task to download locally the kibi dependency
 */
task downloadKibi(type: Copy) {
    from configurations.kibi
    into new File(buildDir, 'dependencies')
    rename { name ->
    println "THE NAME ${name}"
        def artifact = configurations.kibi.resolvedConfiguration.resolvedArtifacts.find { it.file.name == name }
        "${artifact.name}.${artifact.extension}"
    }
}

/**
 * Task to unzip kibi
 */
task extractKibi(type: Copy, dependsOn: [downloadKibi]) {
    from { zipTree(new File(downloadKibi.destinationDir, "investigate-core.zip")) }
    into new File(buildDir, 'investigate-core')
    includeEmptyDirs = false
}

/**
 * Task to execute the `npmInstall` gradle's task from the kibi distribution
 */
task npmInstallKibi(type: NpmTask, dependsOn: [extractKibi]) {
    def kibiInstallDir = new File(extractKibi.destinationDir, "investigate-core-${investigateVersion}-sources")

    execOverrides {
        it.workingDir = kibiInstallDir
    }

    setArgs( ['ci'] )
}

/**
 * Main task to install Kibi locally
 */
task installKibi(dependsOn: [downloadKibi, extractKibi, npmInstallKibi]) {}

///////////////////////////////////////////////////
//                                               //
//                     Node                      //
//                                               //
///////////////////////////////////////////////////

node {
    // Version of node to use.
    version = nodeVersion
    // Base URL for fetching node distributions (change if you have a mirror).
    distBaseUrl = 'https://nodejs.org/dist'

    // If true, it will download node using above parameters.
    // If false, it will try to use globally installed node.
    download = false

    // Set the work directory for unpacking node
    workDir = file("${buildDir}/nodejs")

    // Set the work directory where node_modules should be located
    nodeModulesDir = file("${projectDir}")

    npmInstallCommand = 'ci'
}

///////////////////////////////////////////////////
//                                               //
//                   Package                     //
//                                               //
///////////////////////////////////////////////////

task gulpPackage(dependsOn: ['gulp_package']) {
    doLast {}
}

// run npm install
gulp_package.dependsOn 'npmCi'

///////////////////////////////////////////////////
//                                               //
//           Install Grunt Globally              //
//                                               //
///////////////////////////////////////////////////

task installGruntGlobally(type: NpmTask) {
    args = ['install', '-g', 'grunt']
}

///////////////////////////////////////////////////
//                                               //
//           Install Packages                    //
//                                               //
///////////////////////////////////////////////////

task preNpmCi(type: NpmTask, dependsOn: [installGruntGlobally]) {
    execOverrides {
        it.workingDir = projectDir
    }

    setArgs( ['ci'] )
}

task npmCi(type: Delete, dependsOn: [preNpmCi]) {
    delete "${projectDir}/node_modules/.bin/npm", "${projectDir}/node_modules/npm"
}


///////////////////////////////////////////////////
//                                               //
//                     Dev                       //
//                                               //
///////////////////////////////////////////////////

task gulpDev(type: GulpTask) {
    args = ["dev"]
    if (project.hasProperty('kibiHomePath')) {
        args << "--kibanahomepath=${kibiHomePath}"
    }
    else {
        dependsOn installKibi
        args << "--kibanahomepath=${new File(extractKibi.destinationDir, "investigate-core-${investigateVersion}-sources").getAbsolutePath()}"
    }
}

// run npm install
gulpDev.dependsOn 'npmCi'

// run gulp install
gulpDev.dependsOn 'installGulp'

// makes that grunt is installed
gulpDev.dependsOn 'installGruntGlobally'
gulpDev.dependsOn 'installGrunt'
installGrunt.mustRunAfter 'installGruntGlobally'

///////////////////////////////////////////////////
//                                               //
//                    Test                       //
//                                               //
///////////////////////////////////////////////////

task gulpTest(type: GulpTask) {
    args = ["test"]
    if (project.hasProperty('kibiHomePath')) {
        args << "--kibanahomepath=${kibiHomePath}"
    }
    else {
        dependsOn installKibi
        args << "--kibanahomepath=${new File(extractKibi.destinationDir, "investigate-core-${investigateVersion}-sources").getAbsolutePath()}"
    }
}

// run npm install
gulpTest.dependsOn 'npmCi'

///////////////////////////////////////////////////
//                                               //
//                  Test Dev                     //
//                                               //
///////////////////////////////////////////////////

task gulpTestDev(type: GulpTask) {
    args = ["testdev"]
    if (project.hasProperty('kibiHomePath')) {
        args << "--kibanahomepath=${kibiHomePath}"
    }
    else {
        dependsOn installKibi
        args << "--kibanahomepath=${new File(extractKibi.destinationDir, "investigate-core-${investigateVersion}-sources").getAbsolutePath()}"
    }
}

// run npm install
gulpTestDev.dependsOn 'npmCi'

///////////////////////////////////////////////////
//                                               //
//                    Clean                      //
//                                               //
///////////////////////////////////////////////////

// Extends clean task to clean the node_modules directory
clean {
    doLast {
        def nodeModulesDir = file("${projectDir}/node_modules")
        if (nodeModulesDir.exists()) {
          println "=== Cleaning node modules directory: ${nodeModulesDir} ==="
          nodeModulesDir.deleteDir()
        }
    }
}

// Executes the Gulp's clean task
gulp_clean.dependsOn 'npmCi'
clean.dependsOn 'gulp_clean'

///////////////////////////////////////////////////
//                                               //
//                Publishing                     //
//                                               //
///////////////////////////////////////////////////

publishing {
  repositories getArtifactoryRepository()
  publications {
    zipDist(MavenPublication) {
      artifact(new File("${projectDir}/target/gulp", "${packageJson.name}.zip"))
      groupId project.group
      artifactId "kibi-enhanced-tilemap"
      version project.version
    }
  }
}