build.gradle

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

buildscript {

    repositories {
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }

    dependencies {
        classpath "com.moowork.gradle:gradle-node-plugin:1.1.1"
        classpath 'org.ajoberstar:gradle-git:1.6.0'
    }

}

apply plugin: "idea"
apply plugin: "base"
apply plugin: 'com.moowork.gulp'
apply plugin: 'com.moowork.grunt'
apply plugin: 'com.moowork.node'
apply plugin: 'org.ajoberstar.grgit'
apply plugin: 'maven-publish'
apply from: "$rootDir/gradle/utils/repository.gradle"
apply from: "$rootDir/gradle/utils/loadPackageJson.gradle"

import org.ajoberstar.grgit.Grgit

def packageJson = loadPackageJson()

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

group = 'solutions.siren'
version packageJson.version

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

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

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

/**
 * Task to download locally the kibi dependency
 */
task downloadKibi(type: Copy) {
    from configurations.kibi
    into new File(buildDir, 'dependencies')
    rename { 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')
}

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

/**
 * 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 = true

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

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

///////////////////////////////////////////////////
//                                               //
//                   Package                     //
//                                               //
///////////////////////////////////////////////////
task parseGunMasterUrl () {
    if (project.ext.properties.github_username && project.ext.properties.github_password) {
        def github_username = project.ext.properties.github_username
        def github_password = project.ext.properties.github_password

        def urlParts = gun_master_url =~ /(git\+https:\/\/)(github\.com\/.*)/
        gun_master_url = "${urlParts[0][1]}${github_username}:${github_password}@${urlParts[0][2]}"
    }
}

task gulpPackage(type: GulpTask, dependsOn: [parseGunMasterUrl]) {
    args = ["package", "--lib-install=${gun_master_url}"]
}


// run npm install
gulp_package.dependsOn 'npmInstall'

// run gulp install
gulp_package.dependsOn 'installGulp'

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

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

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

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

// run npm install
gulpDev.dependsOn 'npmInstall'

// 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, dependsOn: [ parseGunMasterUrl ]) {
    args = ["test"]

    if (project.hasProperty('kibiHomePath')) {
        args << "--kibanahomepath=${kibiHomePath}"
        args << "--lib-install=${gun_master_url}"
    }
    else {
        dependsOn installKibi
        args << "--kibanahomepath=${new File(extractKibi.destinationDir, "investigate-core-${project.version}-sources").getAbsolutePath()}"
        args << "--lib-install=${gun_master_url}"
    }
}

// run npm install
gulpTest.dependsOn 'npmInstall'

// run gulp install
gulpTest.dependsOn 'installGulp'

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

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

task gulpTestDev(type: GulpTask, dependsOn: [ parseGunMasterUrl ]) {
    args = ["testdev"]

    if (project.hasProperty('kibiHomePath')) {
        args << "--kibanahomepath=${kibiHomePath}"
        args << "--lib-install=${gun_master_url}"
    }
    else {
        dependsOn installKibi
        args << "--kibanahomepath=${new File(extractKibi.destinationDir, "investigate-core-${project.version}-sources").getAbsolutePath()}"
        args << "--lib-install=${gun_master_url}"
    }
}

// run npm install
gulpTestDev.dependsOn 'npmInstall'

// run gulp install
gulpTestDev.dependsOn 'installGulp'

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

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

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

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

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

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