remove deprecated message artifact generation, merge damons plugin upgrades -...

remove deprecated message artifact generation, merge damons plugin upgrades - use buildscripts and some cleanups.

gradle_plugins/src/main/groovy/org/ros/gradle_plugins/CatkinPlugin.groovy

@@ -4,6 +4,7 @@ import org.gradle.api.Project;
 import org.gradle.api.Plugin;
 import org.gradle.api.Task;
 import org.gradle.api.tasks.JavaExec
+import org.gradle.api.tasks.StopActionException
 
 import org.gradle.api.*;
 
@@ -25,7 +26,7 @@ import org.gradle.api.*;
  *     println d
  *   }
  *   // filtered list of *_msg dependencies.
- *     pkg.messageDependencies().each { d ->
+ *   pkg.getMessageDependencies().each { d ->
  *     println d
  *   }
  * }
@@ -53,7 +54,7 @@ class CatkinPlugin implements Plugin<Project> {
             packageXml = project.file('package.xml')
         }
         if (packageXml != null) {
-            project.catkin.pkg = new CatkinPackage(packageXml)
+            project.catkin.pkg = new CatkinPackage(project, packageXml)
         }
 	    setTasks()
     }
@@ -73,37 +74,40 @@ class CatkinPluginExtension {
   List<String> workspaces
   CatkinPackages tree
 }
+
 class CatkinPackages {
-    def Map<String, CatkinPackage> pkgs
-    def List<String> workspaces
-    def Project project
 
-    def CatkinPackages(Project project, List<String> workspaces) {
+  Map<String, CatkinPackage> pkgs
+  List<String> workspaces
+  Project project
+
+  CatkinPackages(Project project, List<String> workspaces) {
     this.project = project
     this.workspaces = workspaces
-        this.pkgs = [:]
+    pkgs = [:]
   }
 
-    def generate() {
-        if ( this.pkgs.size() == 0 ) {
-            this.workspaces.each { workspace ->
-                def manifestTree = project.fileTree(dir: workspace, include: '**/package.xml')
+  void generate() {
+    if (pkgs.size() == 0) {
+      workspaces.each { workspace ->
+        def manifestTree = project.fileTree(dir: workspace,
+                                            include: "**/package.xml")
         manifestTree.each { file -> 
           def pkg = new CatkinPackage(file)
           if(this.pkgs.containsKey(pkg.name)) {
             if(this.pkgs[pkg.name].version < pkg.version) {
               println("Catkin generate tree: replacing older version of " + pkg.name + "[" + this.pkgs[pkg.name].version + "->" + pkg.version + "]") 
-                            this.pkgs[pkg.name] = pkg
+              pkgs[pkg.name] = pkg
             }
           } else {
-                        this.pkgs.put(pkg.name, pkg)
+            pkgs.put(pkg.name, pkg)
           }
         }
       }
     }
   }
 
-    def isMessagePackage(String package_name) {
+  Boolean isMessagePackage(String package_name) {
     def pkg
     def result = false
     try {
@@ -122,149 +126,70 @@ class CatkinPackages {
     return result
   }
 
-    def void generateMessageArtifact(Project p, String package_name) {
+  void generateMessageArtifact(Project project, String package_name) {
     def pkg = this.pkgs[package_name]
-        p.version = pkg.version
+    project.version = pkg.version
     /* println("Artifact: " + pkg.name + "-" + pkg.version) */
-        p.dependencies.add("compile", 'org.ros.rosjava_bootstrap:message_generation:[0.1,0.2)')
-        List<String> messageDependencies = []
-        pkg.dependencies.each { d ->
-            /* println("  Dependency: " + d) */
-            if ( this.isMessagePackage(d) ) {
-                messageDependencies.add(d)
-                /* println("    Msg Pkg: yes") */
-            } else {
-                /* println("    Msg Pkg: no") */
-            }
-        }
+    project.dependencies.add("compile", 'org.ros.rosjava_bootstrap:message_generation:[0.2,0.3)')
+    Set<String> messageDependencies = pkg.getMessageDependencies()
     messageDependencies.each { d ->
-            if ( p.getParent().getChildProjects().containsKey(d) ) {
+      if ( project.getParent().getChildProjects().containsKey(d) ) {
         /* println("  Internal: " + d) */
-                p.dependencies.add("compile", p.dependencies.project(path: ':' + d))
+        project.dependencies.add("compile", project.dependencies.project(path: ':' + d))
       } else {
         /* println("  External: " + d) */
-                p.dependencies.add("compile", 'org.ros.rosjava_messages:' + d + ':[0.0,)')
+        project.dependencies.add("compile", 'org.ros.rosjava_messages:' + d + ':[0.0,)')
       }
     }
-        def generatedSourcesDir = "${p.buildDir}/generated-src"
-        def generateSourcesTask = p.tasks.create("generateSources", JavaExec)
+    def generatedSourcesDir = "${project.buildDir}/generated-src"
+    def generateSourcesTask = project.tasks.create("generateSources", JavaExec)
     generateSourcesTask.description = "Generate sources for " + pkg.name
-        generateSourcesTask.outputs.dir(p.file(generatedSourcesDir))
+    generateSourcesTask.outputs.dir(project.file(generatedSourcesDir))
     /* generateSourcesTask.args = new ArrayList<String>([generatedSourcesDir, pkg.name]) */
     generateSourcesTask.args = new ArrayList<String>([generatedSourcesDir, '--package-path=' + pkg.directory, pkg.name])
-        generateSourcesTask.classpath = p.configurations.runtime
-        generateSourcesTask.main = 'org.ros.internal.message.GenerateInterfaces'
-        p.tasks.compileJava.source generateSourcesTask.outputs.files
+    generateSourcesTask.classpath = project.configurations.runtime
+    generateSourcesTask.main = "org.ros.internal.message.GenerateInterfaces"
+    project.tasks.compileJava.source generateSourcesTask.outputs.files
   }
 }
 
 class CatkinPackage {
-    def name
-    def version
-    def dependencies
-    def directory
+  Project project
+  String name
+  String version
+  Set<String> dependencies
+  String directory
 
-    def CatkinPackage(File packageXmlFilename) {
+  CatkinPackage(Project project, File packageXmlFilename) {
+    this.project = project
+    /* println "Loading " + packageXmlFilename */
     def packageXml = new XmlParser().parse(packageXmlFilename)
     directory = packageXmlFilename.parent
     name = packageXml.name.text()
     version = packageXml.version.text()
-        dependencies = []
-        packageXml.build_depend.each { d ->
-            dependencies.add(d.text())
-        }
-    }
-    def String toString() {
-        def out = new String()
-        out += name + "\n"
-        out += "  version: " + version + "\n"
-        out += "  dependencies:" + "\n"
-        dependencies.each { d ->
-            out += "    " + d + "\n"
-        }
-        return out
-    }
-    /*
-     * Find and annotate a list of package package dependencies.
-     * Useful for message artifact generation).
-     *
-     * Depracated, but kept around for legacy purposes, remove in igloo
-     *
-     * @return List<String> : dependencies (package name strings)  
-     */
-    def List<String> messageDependencies() {
-        List<String> msgDependencies = []
-        dependencies.each { d ->
-            if ( d.contains("_msgs") ) {
-                msgDependencies.add(d)
-            }
-        }
-        return msgDependencies
+    dependencies = packageXml.build_depend.collect{ it.text() }
   }
 
-    /* Depracated, but kept around for legacy purposes, remove in igloo */
-    def void generateMessageArtifact(Project p) {
-        p.version = version
-        p.dependencies.add("compile", 'org.ros.rosjava_bootstrap:message_generation:[0.1,0.2)')
-        messageDependencies().each { d ->
-            p.dependencies.add("compile", p.dependencies.project(path: ':' + d))
-        }
-        def generatedSourcesDir = "${p.buildDir}/generated-src"
-        def generateSourcesTask = p.tasks.create("generateSources", JavaExec)
-        generateSourcesTask.description = "Generate sources for " + name
-        generateSourcesTask.outputs.dir(p.file(generatedSourcesDir))
-        generateSourcesTask.args = new ArrayList<String>([generatedSourcesDir, name])
-        generateSourcesTask.classpath = p.configurations.runtime
-        generateSourcesTask.main = 'org.ros.internal.message.GenerateInterfaces'
-        p.tasks.compileJava.source generateSourcesTask.outputs.files
-    }
+  String toString() { "${name} ${version} ${dependencies}" }
 
-    /* Depracated, but kept around for legacy purposes, remove in igloo */
-    def void generateUnofficialMessageArtifact(Project p) {
-        /* Couple of constraints here:
-             1) maven group forced to org.ros.rosjava_messages to that all message artifact
-                dependencies are easily found.
-             2) Open ended dependency range (takes the latest in ROS_PACKAGE_PATH) since we
-                don't know the artifact versions the user really wants.
-        */
-        p.version = version
-        p.group = 'org.ros.rosjava_messages'
-        p.dependencies.add("compile", 'org.ros.rosjava_bootstrap:message_generation:[0.1,0.2)')
-        messageDependencies().each { d ->
-            if ( p.getParent().getChildProjects().containsKey(d) ) {
-                p.dependencies.add("compile", p.dependencies.project(path: ':' + d))
-            } else {
-                p.dependencies.add("compile", 'org.ros.rosjava_messages:' + d + ':[0.1,)')
+  Set<String> getTransitiveDependencies(Collection<String> dependencies) {
+    Set<String> result = [];
+    dependencies.each {
+      if (project.catkin.tree.pkgs.containsKey(it)) {
+        result.add(it)
+        result.addAll(getTransitiveDependencies(
+            project.catkin.tree.pkgs[it].dependencies))
       }
     }
-        def generatedSourcesDir = "${p.buildDir}/generated-src"
-        def generateSourcesTask = p.tasks.create("generateSources", JavaExec)
-        generateSourcesTask.description = "Generate sources for " + name
-        generateSourcesTask.outputs.dir(p.file(generatedSourcesDir))
-        generateSourcesTask.args = new ArrayList<String>([generatedSourcesDir, '--package-path=' + directory, name])
-        generateSourcesTask.classpath = p.configurations.runtime
-        generateSourcesTask.main = 'org.ros.internal.message.GenerateInterfaces'
-        p.tasks.compileJava.source generateSourcesTask.outputs.files
+    return result
   }
 
-    /*
-     * Hack to work around for rosjava_test_msgs - look in a subfolder for the
-     * msgs and name the artifact by the subfolder name/version.
-     */
-    def void generateMessageArtifactInSubFolder(Project p, String subfolderName, List<String> dependencies) {
-        // p.version = version use the subfolder's project version
-        p.dependencies.add("compile", 'org.ros.rosjava_bootstrap:message_generation:[0.1,0.2)')
-        dependencies.each { d ->
-            p.dependencies.add("compile", p.dependencies.project(path: ':' + d))
-        }
-        def generatedSourcesDir = "${p.buildDir}/generated-src"
-        def generateSourcesTask = p.tasks.create("generateSources", JavaExec)
-        generateSourcesTask.description = "Generate sources for " + name + "/" + subfolderName
-        generateSourcesTask.outputs.dir(p.file(generatedSourcesDir))
-        generateSourcesTask.args = new ArrayList<String>([generatedSourcesDir, subfolderName])
-        generateSourcesTask.classpath = p.configurations.runtime
-        generateSourcesTask.main = 'org.ros.internal.message.GenerateInterfaces'
-        p.tasks.compileJava.source generateSourcesTask.outputs.files
+  Set<String> getMessageDependencies() {
+    getTransitiveDependencies(dependencies).findAll {
+      project.catkin.tree.pkgs.containsKey(it) &&
+      project.catkin.tree.pkgs[it].dependencies.contains("message_generation")
+    } as Set
   }
+
 }
 

gradle_plugins/src/main/groovy/org/ros/gradle_plugins/RosAndroid.groovy

@@ -4,35 +4,20 @@ import org.gradle.api.Project
 import org.gradle.api.Plugin
 import java.util.HashMap
 
-/*
- * Configures java for the ros-android build environment. Pretty elementary right now,
- * just applies the java plugin and defines the jdk compatibility level.
+/**
+ * Configures ROS on Android build environment.
  */
 class RosAndroidPlugin implements Plugin<Project> {
-    Project project
-    
-	def void apply(Project project) {
-	    this.project = project
-        if (!project.plugins.findPlugin('ros')) {
-            project.apply(plugin: 'ros')
-        }
+  void apply(Project project) {
+    project.apply plugin: "ros"
     project.extensions.create("rosandroid", RosAndroidPluginExtension)
     project.rosandroid.buildToolsVersion = "19.1.0"
-        /*********************************************************************
-         * Find the android plugin
-         *********************************************************************/ 
-        project.buildscript {
-            repositories {
-                mavenCentral()
-            }
-            dependencies {
-                classpath 'com.android.tools.build:gradle:0.11.+'
-            }
-        }
+
     /********************************************************************** 
      * Publishing - not we're using old style here. Upgrade to maven-publish
      * once they have support: 
      *   https://github.com/rosjava/rosjava_bootstrap/issues/1 
+     * This is specifically for releasing and working in a ros workspace.
      **********************************************************************/ 
     project.uploadArchives {
       repositories.mavenDeployer {
@@ -43,11 +28,9 @@ class RosAndroidPlugin implements Plugin<Project> {
      * Our maven repo 3rd parties are currently incompatible with android
      * junit especially could use a look at - find a compatible version!
      **********************************************************************/
-        project.configurations.create('compile')
-        def excludes = new HashMap<String, String>()
-        excludes.put('group', 'junit')
-        excludes.put('group', 'xml-apis')
-        project.configurations['compile'].exclude(excludes)
+    project.configurations.maybeCreate("compile")
+    project.configurations.compile.exclude "group": "junit"
+    project.configurations.compile.exclude "group": "xml-apis"
     /**********************************************************************
      * Delay android plugin configuration because that will depend on
      * the subproject's late loading of android or android-library plugin.
@@ -57,7 +40,6 @@ class RosAndroidPlugin implements Plugin<Project> {
         buildToolsVersion project.rosandroid.buildToolsVersion
       }
     }
-        
   }
 }
 

gradle_plugins/src/main/groovy/org/ros/gradle_plugins/RosPlugin.groovy

 package org.ros.gradle_plugins;
 
-import org.gradle.api.Project;
-import org.gradle.api.Plugin;
 import org.gradle.api.*;
+import org.gradle.api.publish.maven.MavenPublication;
 
-/*
- * Provides information about the ros workspace.
+/**
+ * Configures a Java project for use with ROS.
  *
  * - project.ros.mavenPath : location of local ros maven repositories (in your chained workspaces)
  * - project.ros.mavenDeploymentRepository : location of the ros maven repository you will publish to
@@ -17,48 +16,50 @@ import org.gradle.api.*;
  * - configures the uploadArchives for artifact deployment to the local ros maven repo (devel/share/maven)
  */
 class RosPlugin implements Plugin<Project> {
-    Project project
 
   def void apply(Project project) {
-	    this.project = project
-        if (!project.plugins.findPlugin('maven')) {
-            project.apply(plugin: 'maven')
-        }
-        /* Create project.ros.* property extensions */
-        project.extensions.create("ros", RosExtension)
-        project.ros.mavenPath = "$System.env.ROS_MAVEN_PATH".split(':')
-        project.ros.mavenDeploymentRepository = "$System.env.ROS_MAVEN_DEPLOYMENT_REPOSITORY"
-        def mavenRepository = "$System.env.ROS_MAVEN_REPOSITORY"
-        if ( mavenRepository != 'null' ) {
-            project.ros.mavenRepository = mavenRepository
+    project.apply plugin: "maven"
+
+    project.extensions.create("ros", RosPluginExtension)
+
+    project.ros.mavenRepository = System.getenv("ROS_MAVEN_REPOSITORY")
+    project.ros.mavenDeploymentRepository = System.getenv("ROS_MAVEN_DEPLOYMENT_REPOSITORY")
+    String mavenPath = System.getenv("ROS_MAVEN_PATH")
+    if (mavenPath != null) {
+      project.ros.mavenPath = mavenPath.tokenize(":")
     }
-        /* 
-         * Could use some better handling for when this is not defined as it sets
-         * file://null, but it doesn't seem to hurt the process any
-         */
-        def repoURLs = project.ros.mavenPath.collect { 'file://' + it }
     project.repositories {
-            repoURLs.each { p ->
+      if (project.ros.mavenPath != null) {
+        project.ros.mavenPath.each { path ->
           maven {
-                    url p
+            url project.uri(path)
           }
         }
-            mavenLocal()
+      }
+      if (project.ros.mavenRepository != null) {
         maven {
           url project.ros.mavenRepository
         }
+      }
+      mavenLocal()
+      maven {
+        url "http://repository.springsource.com/maven/bundles/release"
+      }
+      maven {
+        url "http://repository.springsource.com/maven/bundles/external"
+      }
       mavenCentral()
     }
   }
 }
 
 /* http://www.gradle.org/docs/nightly/dsl/org.gradle.api.plugins.ExtensionAware.html */
-class RosExtension {
-    List<String> mavenPath
-    String mavenDeploymentRepository
+class RosPluginExtension {
   String mavenRepository
+  String mavenDeploymentRepository
+  List<String> mavenPath
 
-    RosExtension() {
+  RosPluginExtension() {
     /* Initialising the strings here gets rid of the dynamic property deprecated warnings. */
     this.mavenDeploymentRepository = ""
     this.mavenRepository = "https://github.com/rosjava/rosjava_mvn_repo/raw/master"