V 0.4

Author: itaimarko

build.gradle

@@ -0,0 +1,18 @@
+
+apply plugin: 'groovy'
+apply plugin: 'maven'
+
+group = 'org.whitesource'
+version = '0.4'
+
+repositories {
+    mavenLocal()
+    mavenCentral()
+}
+
+dependencies {
+    compile gradleApi()
+    compile localGroovy()
+    compile 'org.whitesource:wss-agent-api-client:2.2.5', 'org.whitesource:wss-agent-report:2.2.5'
+    testCompile group: 'junit', name: 'junit', version: '4.11'
+}

settings.gradle

@@ -0,0 +1 @@
+rootProject.name = 'whitesource-gradle-plugin'

src/main/groovy/org/whitesource/gradle/WhitesourceConfiguration.groovy

@@ -0,0 +1,124 @@
+package org.whitesource.gradle
+
+import org.gradle.api.Project
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.artifacts.Dependency
+import org.gradle.api.specs.Spec
+
+/**
+ * @author Itai Marko
+ */
+class WhitesourceConfiguration {
+
+    String orgToken
+    String productName
+    String productVersion
+    Set<Project> includedProjects = []
+    Set<Configuration> includedConfigurations = []
+    Set<String> includedConfigurationNames = []
+    Spec<? super Dependency> dependencyFilter
+    /*String*/boolean checkPolicies
+    File reportsDirectory
+    boolean failOnRejection = true
+    boolean forceUpdate = false
+
+    String projectToken
+    Map<String, String> projectTokens = [:]
+
+    String requesterEmail
+    boolean failOnError = true
+
+
+    ProxyConfiguration proxyConf
+
+    void orgToken(String orgToken) {
+        this.orgToken = orgToken
+    }
+
+    void productName(String productName) {
+        this.productName = productName
+    }
+
+    void productVersion(String productVersion) {
+        this.productVersion = productVersion
+    }
+
+    void includeProject(Project project) {
+        this.includedProjects << project
+    }
+
+    void includeProjects(Collection<Project> projects) {
+        this.includedProjects += projects
+    }
+
+    void includeConfiguration(Configuration configuration) {
+        this.includedConfigurations << configuration
+    }
+
+    void includeConfiguration(String configurationName) {
+        this.includedConfigurationNames << configurationName
+    }
+
+    void includeConfigurations(Collection<Configuration> configurations) {
+        this.includedConfigurations += configurations
+    }
+
+    void dependencyFilter(Spec<? super Dependency> dependencyFilter) {
+        this.dependencyFilter = dependencyFilter
+    }
+
+    void checkPolicies(/*String*/boolean checkPolicies) {
+        this.checkPolicies = checkPolicies
+    }
+
+    void reportsDirectory(File reportsDirectory) {
+        this.reportsDirectory = reportsDirectory
+    }
+
+    void failOnRejection(boolean failOnRejection) {
+        this.failOnRejection = failOnRejection
+    }
+
+    void forceUpdate(boolean forceUpdate) {
+        this.forceUpdate = forceUpdate
+    }
+
+    void host(String host) {
+        this.proxyConf.host = host
+    }
+
+    void port(String port) {
+        this.proxyConf.port = port
+    }
+
+    void user(String user) {
+        this.proxyConf.user = user
+    }
+
+    void password(String password) {
+        this.proxyConf.password = password
+    }
+
+    void projectToken(String projectToken) {
+        this.projectToken = projectToken
+    }
+
+    void projectTokens(Map<String, String> projectTokens) {
+        this.projectTokens = projectTokens
+    }
+
+    void requesterEmail(String requesterEmail) {
+        this.requesterEmail = requesterEmail
+    }
+
+    void failOnError(boolean failOnError) {
+        this.failOnError = failOnError
+    }
+}
+
+class ProxyConfiguration {
+    String host
+    String port
+    String user
+    String password
+}

src/main/groovy/org/whitesource/gradle/WhitesourcePlugin.groovy

@@ -0,0 +1,86 @@
+package org.whitesource.gradle
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.Task
+import org.gradle.api.artifacts.Dependency
+import org.gradle.api.artifacts.ExternalDependency
+import org.gradle.api.artifacts.FileCollectionDependency
+import org.gradle.api.internal.project.ProjectInternal
+import org.gradle.api.specs.Spec
+import org.whitesource.gradle.tasks.CollectProjectInfoTask
+import org.whitesource.gradle.tasks.UpdateWhitesourceInventoryTask
+
+/**
+ * @author Itai Marko
+ */
+class WhitesourcePlugin implements Plugin<Project> {
+
+    @Override
+    void apply(Project project) {
+        project.configure(project) {
+            project.ext {
+                projectInfos = []
+                includeAllDependencies =
+                        new Spec<Dependency>(){
+                            @Override
+                            boolean isSatisfiedBy(Dependency dep) {
+                                return true
+                            }
+                        }
+                defaultDependencyFilter =
+                        new Spec<Dependency>(){
+                            @Override
+                            boolean isSatisfiedBy(Dependency dep) {
+                                return dep instanceof ExternalDependency
+                            }
+                        }
+                includeExternalOrFileDependencies =
+                        new Spec<Dependency>(){
+                            @Override
+                            boolean isSatisfiedBy(Dependency dep) {
+                                return dep instanceof ExternalDependency || dep instanceof FileCollectionDependency
+                            }
+                        }
+            }
+
+            // create extension objects
+            def wssConfig = project.extensions.create('whitesource', WhitesourceConfiguration)
+            project.whitesource.extensions.create('proxy', ProxyConfiguration)
+
+            afterEvaluate {
+                //set defaults
+                wssConfig.productName = wssConfig.productName ?: rootProject.name
+                wssConfig.includedProjects = wssConfig.includedProjects ?: allprojects
+                if (!(wssConfig.includedConfigurations || wssConfig.includedConfigurationNames)) {
+                    wssConfig.includedConfigurationNames << 'runtime'
+                }
+                wssConfig.dependencyFilter = wssConfig.dependencyFilter ?: project.defaultDependencyFilter
+                if (wssConfig.checkPolicies) {
+
+                    if (!wssConfig.reportsDirectory) {
+                        wssConfig.reportsDirectory = ((ProjectInternal)project).fileResolver.withBaseDir(project.buildDir).resolve('reports')
+                    }
+                }
+
+                // create a collectProjectInfo task for each of the included projects
+                def collectProjectInfoTaskName = 'collectProjectInfo'
+                configure (wssConfig.includedProjects) {
+                    tasks.create(name: collectProjectInfoTaskName, type: CollectProjectInfoTask) {
+                        group = 'whitesource'
+                    }
+                }
+
+                // create an updateWhitesource task for the root project
+                Task uwi = tasks.create(name: 'updateWhitesource', type: UpdateWhitesourceInventoryTask) {
+                    group = 'whitesource'
+                }
+
+                // set the updateWhitesource task to depend on each collectProjectInfo task created
+                uwi.dependsOn wssConfig.includedProjects.collect {
+                    it.tasks.findByName(collectProjectInfoTaskName)
+                }
+            }
+        }
+    }
+}

src/main/groovy/org/whitesource/gradle/tasks/CollectProjectInfoTask.groovy

@@ -0,0 +1,51 @@
+package org.whitesource.gradle.tasks
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.tasks.TaskAction
+import org.whitesource.agent.api.ChecksumUtils
+import org.whitesource.agent.api.model.AgentProjectInfo
+import org.whitesource.agent.api.model.Coordinates
+import org.whitesource.agent.api.model.DependencyInfo
+import org.whitesource.gradle.WhitesourceConfiguration
+
+/**
+ * @author Itai Marko
+ */
+class CollectProjectInfoTask extends DefaultTask {
+
+    WhitesourceConfiguration wssConfig = project.whitesource
+
+    @TaskAction
+    def CollectProjectInfos() {
+        logger.lifecycle("processing ${project.name}")
+        def projectInfo = new AgentProjectInfo()
+        projectInfo.setCoordinates(new Coordinates(null, project.name, null))
+        if (project.parent)
+            projectInfo.setParentCoordinates(new Coordinates(null, project.parent.name, null))
+
+        if (wssConfig.includedProjects.size() > 1) {
+            projectInfo.setProjectToken(wssConfig.projectTokens.get(project.name))
+        } else {
+            projectInfo.setProjectToken(wssConfig.projectToken)
+        }
+
+        def configurationsToInclude = project.configurations.findAll { thisProjConf ->
+            thisProjConf.name in wssConfig.includedConfigurationNames || thisProjConf.name in wssConfig.includedConfigurations*.name
+        }
+
+        def addedSha1s = new HashSet<String>()
+        configurationsToInclude*.resolvedConfiguration*.getFiles(wssConfig.dependencyFilter).flatten().each {
+            def sha1 = ChecksumUtils.calculateSHA1(it)
+            if (!addedSha1s.contains(sha1)) {
+                def dependencyInfo = new DependencyInfo()
+                dependencyInfo.setArtifactId(it.name)
+                dependencyInfo.setSystemPath(it.absolutePath)
+                dependencyInfo.setSha1(sha1)
+                projectInfo.getDependencies().add(dependencyInfo)
+                addedSha1s.add(sha1)
+            }
+        }
+
+        project.projectInfos.add(projectInfo)
+    }
+}