another step forward.

.gitignore

+*.pyc

CMakeLists.txt

@@ -6,13 +6,13 @@ cmake_minimum_required(VERSION 2.8.3)
 project(genjava)
 
 ##############################################################################
-# Dependencies
+# Find Package
 ##############################################################################
 
 find_package(catkin REQUIRED COMPONENTS genmsg)
 
 ##############################################################################
-# Package
+# Catkin
 ##############################################################################
 
 catkin_package(
@@ -20,16 +20,23 @@ catkin_package(
   CFG_EXTRAS genjava-extras.cmake
 )
 
+catkin_python_setup()
+
+##############################################################################
+# Installs
+##############################################################################
+
 add_subdirectory(scripts)
 
-message(STATUS "GENMSG_LANGS_DESTINATION...........${GENMSG_LANGS_DESTINATION}")
 file(WRITE ${CATKIN_DEVEL_PREFIX}/${GENMSG_LANGS_DESTINATION}/genjava "Java")
 install(FILES ${CATKIN_DEVEL_PREFIX}/${GENMSG_LANGS_DESTINATION}/genjava
   DESTINATION ${GENMSG_LANGS_DESTINATION})
 
-catkin_python_setup()
+##############################################################################
+# Tests
+##############################################################################
 
-if(CATKIN_ENABLE_TESTING)
-  catkin_add_nosetests(test)
-endif()
+#if(CATKIN_ENABLE_TESTING)
+#  catkin_add_nosetests(test)
+#endif()
 

cmake/genjava-extras.cmake.em

@@ -6,20 +6,12 @@ set(GENJAVA_BIN_DIR "@(CMAKE_CURRENT_SOURCE_DIR)/scripts")
 set(GENJAVA_BIN_DIR "${GENJAVA_DIR}/../../../@(CATKIN_PACKAGE_BIN_DESTINATION)")
 @[end if]@
 
-set(GENMSG_JAVA_BIN ${GENJAVA_BIN_DIR}/genmsg_java.py)
-set(GENSRV_JAVA_BIN ${GENJAVA_BIN_DIR}/gensrv_java.py)
+set(GENJAVA_BIN ${GENJAVA_BIN_DIR}/genjava_gradle_project.py)
+set(genjava_INSTALL_DIR "maven/org/ros/rosjava_messages")
 
-# genmsg usually uses this variable to configure the install location. we typically pick
-# it up from the environment configured by rosjava_build_tools.
-#set(genjava_INSTALL_DIR "maven/org/ros/rosjava_messages")
-set(ROS_MAVEN_DEPLOYMENT_REPOSITORY $ENV{ROS_MAVEN_DEPLOYMENT_REPOSITORY})
-if(NOT ROS_MAVEN_DEPLOYMENT_REPOSITORY)
-  set(ROS_MAVEN_DEPLOYMENT_REPOSITORY "${CATKIN_DEVEL_PREFIX}/${CATKIN_GLOBAL_MAVEN_DESTINATION}")
-endif()
+macro(_generate_msg_java ARG_PKG ARG_MSG ARG_IFLAGS ARG_MSG_DEPS ARG_GEN_OUTPUT_DIR)
+  list(APPEND ALL_GEN_OUTPUT_FILES_java ${ARG_MSG} ${ARG_MSG_DEPS})
 
-# Generate .msg->.h for py
-# The generated .h files should be added ALL_GEN_OUTPUT_FILES_py
-#
     # Example arguments:
     #
     #   ARG_PKG      : foo_msgs
@@ -27,97 +19,78 @@ endif()
     #   ARG_IFLAGS   : -Ifoo_msgs:/mnt/zaphod/ros/rosjava/hydro/src/foo_msgs/msg;-Istd_msgs:/opt/ros/hydro/share/std_msgs/cmake/../msg
     #   ARG_MSG_DEPS : ???
     #   ARG_GEN_OUTPUT_DIR : /mnt/zaphod/ros/rosjava/hydro/devel/${genjava_INSTALL_DIR}/foo_msgs
-macro(_generate_msg_java ARG_PKG ARG_MSG ARG_IFLAGS ARG_MSG_DEPS ARG_GEN_OUTPUT_DIR)
-
-  message(STATUS "GEN_MSG_JAVA..........._generate_msg_java")
-  message(STATUS "  ARG_PKG..............${ARG_PKG}")
-  message(STATUS "  ARG_MSG..............${ARG_MSG}")
-  message(STATUS "  ARG_IFLAGS...........${ARG_IFLAGS}")
-  message(STATUS "  ARG_MSG_DEPS.........${ARG_MSG_DEPS}")
-  message(STATUS "  ARG_GEN_OUTPUT_DIR...${ARG_GEN_OUTPUT_DIR}")
-  message(STATUS "GEN_MSG_JAVA...........done")
-  message(STATUS "CMAKE_CURRENT_BINARY_DIR.......${CMAKE_CURRENT_BINARY_DIR}")
-
-  #Append msg to output dir
-  #set(GEN_OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}")
-  #file(MAKE_DIRECTORY ${GEN_OUTPUT_DIR})
-  #Create input and output filenames
-  get_filename_component(MSG_SHORT_NAME ${ARG_MSG} NAME_WE)
-
-  file(REMOVE_RECURSE ${CMAKE_CURRENT_BINARY_DIR}/gradle)
-
-  #set(MSG_GENERATED_NAME ${MSG_SHORT_NAME}.java)
-  #set(GEN_OUTPUT_FILE ${GEN_OUTPUT_DIR}/${MSG_GENERATED_NAME})
-  #message(STATUS "GEN_OUTPUT_FILE..........${GEN_OUTPUT_FILE}")
-  #add_custom_command(OUTPUT ${GEN_OUTPUT_FILE}
-  #  DEPENDS ${GENMSG_JAVA_BIN} ${ARG_MSG} ${ARG_MSG_DEPS}
-  #  COMMAND ${CATKIN_ENV} cmake
-  #  -E remove_directory ${CMAKE_CURRENT_BINARY_DIR}
-  #  -m ${ARG_MSG}
-  #  ${ARG_IFLAGS}
-  #  -p ${ARG_PKG}
-  #  -o ${GEN_OUTPUT_DIR}
-  #  COMMENT "Generating Java code from MSG ${ARG_PKG}/${MSG_SHORT_NAME}"
-  #)
-
-  #list(APPEND ALL_GEN_OUTPUT_FILES_java ${GEN_OUTPUT_FILE})
     
+    #message(STATUS "Java generator for [${ARG_PKG}][${ARG_MSG}]")
+    #message(STATUS "  ARG_IFLAGS...........${ARG_IFLAGS}")
+    #message(STATUS "  ARG_MSG_DEPS.........${ARG_MSG_DEPS}")
+    #message(STATUS "  ARG_GEN_OUTPUT_DIR...${ARG_GEN_OUTPUT_DIR}")
+    #message(STATUS "GEN_MSG_JAVA...........done")
+    #message(STATUS "CMAKE_CURRENT_BINARY_DIR.......${CMAKE_CURRENT_BINARY_DIR}")
 endmacro()
 
-#todo, these macros are practically equal. Check for input file extension instead
 macro(_generate_srv_java ARG_PKG ARG_SRV ARG_IFLAGS ARG_MSG_DEPS ARG_GEN_OUTPUT_DIR)
-
-  message(STATUS "GEN_SRV_JAVA..........._generate_srv_java")
-  #Append msg to output dir
-#  set(GEN_OUTPUT_DIR "${ARG_GEN_OUTPUT_DIR}/srv")
-#  file(MAKE_DIRECTORY ${GEN_OUTPUT_DIR})
-#
-  #Create input and output filenames
-#  get_filename_component(SRV_SHORT_NAME ${ARG_SRV} NAME_WE)
-#
-#  set(SRV_GENERATED_NAME _${SRV_SHORT_NAME}.py)
-#  set(GEN_OUTPUT_FILE ${GEN_OUTPUT_DIR}/${SRV_GENERATED_NAME})
-#
-#  add_custom_command(OUTPUT ${GEN_OUTPUT_FILE}
-#    DEPENDS ${GENSRV_PY_BIN} ${ARG_SRV} ${ARG_MSG_DEPS}
-#    COMMAND ${CATKIN_ENV} ${PYTHON_EXECUTABLE} ${GENSRV_PY_BIN} ${ARG_SRV}
-#    ${ARG_IFLAGS}
-#    -p ${ARG_PKG}
-#    -o ${GEN_OUTPUT_DIR}
-#    COMMENT "Generating Python code from SRV ${ARG_PKG}/${SRV_SHORT_NAME}"
-#    )
-#
-#  list(APPEND ALL_GEN_OUTPUT_FILES_py ${GEN_OUTPUT_FILE})
-
+  list(APPEND ALL_GEN_OUTPUT_FILES_java ${ARG_SRV} ${ARG_MSG_DEPS})
 endmacro()
 
+# This is a bit different to the other generators - it generates the whole message package together
+# (unless there's another api I'm not aware of yet in the generator jar). It's a few milliseconds
+# of overkill generating all .java files if only one msg changed, but it's not worth the effort to
+# break that down yet.
+# 
+# To facilitate this, the ARG_GENERATED_FILES is actually just the underlying ARG_MSG and ARG_SRV
+# files which we feed the commands as DEPENDS to trigger their execution.
 macro(_generate_module_java ARG_PKG ARG_GEN_OUTPUT_DIR ARG_GENERATED_FILES)
 
-  message(STATUS "GEN_MODULE_JAVA..........._generate_module_java")
-  # generate empty __init__ to make parent folder of msg/srv a python module
-  if(NOT EXISTS ${ARG_GEN_OUTPUT_DIR}/__init__.py)
-    file(WRITE ${ARG_GEN_OUTPUT_DIR}/__init__.py "")
+    ################################
+    # Gradle Subproject
+    ################################
+    set(GRADLE_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/java")
+    set(GRADLE_BUILD_FILE "${GRADLE_BUILD_DIR}/${ARG_PKG}/build.gradle")
+    list(APPEND ALL_GEN_OUTPUT_FILES_java ${GRADLE_BUILD_FILE})
+
+    add_custom_command(OUTPUT ${GRADLE_BUILD_FILE}
+        DEPENDS ${GENJAVA_BIN}
+        COMMAND ${CATKIN_ENV} ${PYTHON_EXECUTABLE} ${GENJAVA_BIN}
+            -o ${GRADLE_BUILD_DIR}
+            -p ${ARG_PKG}
+        COMMENT "Generating Java gradle project from ${ARG_PKG}"
+    )
+
+    ################################
+    # Compile Gradle Subproject
+    ################################
+    set(ROS_GRADLE_VERBOSE $ENV{ROS_GRADLE_VERBOSE})
+    if(ROS_GRADLE_VERBOSE)
+        set(GRADLE_CMD "./gradlew")
+    else()
+        set(GRADLE_CMD "./gradlew;-q")
     endif()
+    set(GEN_OUTPUT_FILE ${CMAKE_CURRENT_BINARY_DIR}/generated_java_messages.flag)
 
-  #Append msg to output dir
-  foreach(type "msg" "srv")
-    set(GEN_OUTPUT_DIR "${ARG_GEN_OUTPUT_DIR}/${type}")
-    set(GEN_OUTPUT_FILE ${GEN_OUTPUT_DIR}/__init__.py)
-
-    if(IS_DIRECTORY ${GEN_OUTPUT_DIR})
     add_custom_command(OUTPUT ${GEN_OUTPUT_FILE}
-        DEPENDS ${GENMSG_PY_BIN} ${ARG_GENERATED_FILES}
-        COMMAND ${CATKIN_ENV} ${PYTHON_EXECUTABLE} ${GENMSG_PY_BIN}
-        -o ${GEN_OUTPUT_DIR}
-        --initpy
-        COMMENT "Generating Python ${type} __init__.py for ${ARG_PKG}")
-      list(APPEND ALL_GEN_OUTPUT_FILES_py ${GEN_OUTPUT_FILE})
-    endif()
-
-  endforeach()
-
+        DEPENDS ${GRADLE_BUILD_FILE} ${ARG_GENERATED_FILES}
+        COMMAND ${CATKIN_ENV} ${GRADLE_CMD}
+        COMMAND touch ${GEN_OUTPUT_FILE}
+        WORKING_DIRECTORY ${GRADLE_BUILD_DIR}/${ARG_PKG}
+        COMMENT "Generating Java code for ${ARG_PKG}")
+    list(APPEND ALL_GEN_OUTPUT_FILES_java ${GEN_OUTPUT_FILE})
+
+    ################################
+    # Debugging
+    ################################
+    #foreach(gen_output_file ${ALL_GEN_OUTPUT_FILES_java})
+    #    message(STATUS "ALL_GEN_OUTPUT_FILES_java..........${gen_output_file}")
+    #endforeach()
+
+    ################################
+    # Dependent Targets
+    ################################
+    # Make sure we have built gradle-rosjava_bootstrap if it is in the source workspace
+    # (otherwise package.xml will make sure it has installed via rosdep/deb.
+    #if(TARGET gradle-rosjava_bootstrap)
+        # Preference would be to add it to ${ARG_PKG}_generate_messages_java but that
+        # is not defined till after this module is parsed, so add it all
+        #add_dependencies(${ARG_PKG}_generate_messages gradle-rosjava_bootstrap)
+    #endif()
 endmacro()
 
-if(NOT EXISTS @(PROJECT_NAME)_SOURCE_DIR)
-  set(GENJAVA_INSTALL_DIR ${PYTHON_INSTALL_DIR})
-endif()
\ No newline at end of file

package.xml

@@ -18,8 +18,14 @@
   <buildtool_depend version_gte="0.5.78">catkin</buildtool_depend>
 
   <build_depend>genmsg</build_depend>
+  <build_depend>python-catkin-pkg</build_depend>
+  <build_depend>python-rospkg</build_depend>
+  <build_depend>rosjava_bootstrap</build_depend>
 
   <run_depend>genmsg</run_depend>
+  <run_depend>python-catkin-pkg</run_depend>
+  <run_depend>python-rospkg</run_depend>
+  <run_depend>rosjava_bootstrap</run_depend>
 
   <export>
     <message_generator>java</message_generator>

scripts/CMakeLists.txt

+##############################################################################
+# Installs
+##############################################################################
+
 catkin_install_python(
-  PROGRAMS genjava.py gensrv_java.py
-  DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION})
+    PROGRAMS genjava_gradle_project.py
+    DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
+)

scripts/genjava.py → scripts/genjava_gradle_project.py

@@ -8,9 +8,8 @@ Converts ROS .msg files in a package into Java source code implementations.
 import os
 import sys
 
-#import genjava.generator
-import genjava.genjava_main
+import genjava
 
 if __name__ == "__main__":
-    genjava.genjava_main.genmain(sys.argv, 'genmsg_java.py') #, genpy.generator.MsgGenerator())
+    genjava.main(sys.argv)
 

src/genjava/__init__.py

@@ -35,3 +35,5 @@
 
 #__all__ = ['Time', 'Duration', 'TVal',
 #        'Message', 'SerializationError', 'DeserializationError', 'MessageException', 'struct_I']
+
+from .genjava_main import main

src/genjava/genjava_main.py

@@ -36,46 +36,49 @@
 
 from __future__ import print_function
 import argparse
-import os
+#import os
 #import sys
 #import traceback
 #import genmsg
-import genmsg.command_line
+#import genmsg.command_line
 
 #from genmsg import MsgGenerationException
 #from . generate_initpy import write_modules
+from . import gradle_project
 
 ##############################################################################
 # Methods
 ##############################################################################
 
 
-def parse_arguments():
+def parse_arguments(argv):
     '''
       The include path has a special format, e.g.
          -Ifoo_msgs:/mnt/zaphod/ros/rosjava/hydro/src/foo_msgs/msg;-Istd_msgs:/opt/ros/hydro/share/std_msgs/cmake/../msg
     '''
     parser = argparse.ArgumentParser(description='Generate java code for a single ros message.')
-    parser.add_argument('-m', '--message', action='store', help='the message file')
+    #parser.add_argument('-m', '--message', action='store', help='the message file')
     parser.add_argument('-p', '--package', action='store', help='package to find the message file')
     parser.add_argument('-o', '--output-dir', action='store', help='output directory for the java code (e.g. build/foo_msgs)')
-    parser.add_argument('-I', '--include-path', action='append', help="include paths to the package and deps msg files")
+    #parser.add_argument('-I', '--include-path', action='append', help="include paths to the package and deps msg files")
     #myargs = rospy.myargv(argv=sys.argv)
     #return parser.parse_args(args=myargs[1:])
-    return parser.parse_args()
+    return parser.parse_args(argv)
 
 ##############################################################################
 # Main
 ##############################################################################
 
-def genmain(argv, progname):  # , gen):
-    args = parse_arguments()
-    print("genjava %s/%s" % (args.package, args.message))
+
+def main(argv):
+    args = parse_arguments(argv[1:])
+    #print("genjava %s/%s" % (args.package, args.message))
     print("  output dir..........%s" % args.output_dir)
-    search_path = genmsg.command_line.includepath_to_dict(args.include_path)
-    print("  search path.......%s" % search_path)
-    gradle_project_dir = os.path.join(args.output_dir, 'gradle')
-    os.mkdir(gradle_project_dir)
+    gradle_project.create(args.package, args.output_dir)
+    #search_path = genmsg.command_line.includepath_to_dict(args.include_path)
+    #print("  search path.......%s" % search_path)
+    #gradle_project_dir = os.path.join(args.output_dir, 'gradle')
+    #os.mkdir(gradle_project_dir)
 
 #     try:
 #         if options.initpy:

src/genjava/gradle/Readme.md

+This is not installed, but it gets used to generate the gradle wrapper for a project.
+
+It is currently the gradle wrapper supporting gradle 1.9.
\ No newline at end of file

src/genjava/gradle/gradle/wrapper/gradle-wrapper.properties

+#Wed Mar 19 17:27:39 KST 2014
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=http\://services.gradle.org/distributions/gradle-1.11-bin.zip

src/genjava/gradle/gradlew

+#!/usr/bin/env bash
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+esac
+
+# For Cygwin, ensure paths are in UNIX format before anything is touched.
+if $cygwin ; then
+    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
+fi
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >&-
+APP_HOME="`pwd -P`"
+cd "$SAVED" >&-
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
+}
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"

src/genjava/gradle_project.py

+#!/usr/bin/env python
+
+##############################################################################
+# Imports
+##############################################################################
+
+from __future__ import print_function
+
+import os
+import shutil
+
+# local imports
+#import utils
+from catkin_pkg.packages import find_packages
+import rospkg
+
+##############################################################################
+# Utils
+##############################################################################
+
+import pwd
+
+
+def author_name():
+    """
+    Utility to compute logged in user name
+
+    :returns: name of current user, ``str``
+    """
+    import getpass
+    name = getpass.getuser()
+    try:
+        login = name
+        name = pwd.getpwnam(login)[4]
+        name = ''.join(name.split(','))  # strip commas
+        # in case pwnam is not set
+        if not name:
+            name = login
+    except:
+        #pwd failed
+        pass
+    #if type(name) == str:
+    #    name = name.decode('utf-8')
+    return name
+
+
+import subprocess
+
+
+def create_gradle_wrapper(repo_path):
+    gradle_binary = os.path.join(os.path.dirname(__file__), 'gradle', 'gradlew')
+    cmd = [gradle_binary, '-p', repo_path, 'wrapper']
+    print("Creating gradle wrapper: %s" % ' '.join(cmd))
+    try:
+        subprocess.check_call(cmd)
+    except subprocess.CalledProcessError:
+        raise subprocess.CalledProcessError("failed to create the gradle wrapper.")
+
+
+def read_template(tmplf):
+    f = open(tmplf, 'r')
+    try:
+        t = f.read()
+    finally:
+        f.close()
+    return t
+
+##############################################################################
+# Methods acting on classes
+##############################################################################
+
+
+def instantiate_genjava_template(template, project_name, project_version, pkg_directory, author, msg_dependencies):
+    return template % locals()
+
+
+def get_templates():
+    template_dir = os.path.join(os.path.dirname(__file__), 'templates', 'genjava_project')
+    templates = {}
+    templates['build.gradle'] = read_template(os.path.join(template_dir, 'build.gradle.in'))
+    return templates
+
+
+def populate_project(project_name, project_version, pkg_directory, gradle_project_dir, msg_dependencies):
+    author = author_name()
+    for filename, template in get_templates().iteritems():
+        contents = instantiate_genjava_template(template, project_name, project_version, pkg_directory, author, msg_dependencies)
+        try:
+            p = os.path.abspath(os.path.join(gradle_project_dir, filename))
+            f = open(p, 'w')
+            f.write(contents)
+            #console.pretty_print("Created file: ", console.cyan)
+            #console.pretty_println("%s" % p, console.yellow)
+        finally:
+            f.close()
+
+
+def create_dependency_string(project_name, msg_package_index):
+    package = msg_package_index[project_name]
+    gradle_dependency_string = ""
+    for dep in package.build_depends:
+        try:
+            dependency_package = msg_package_index[dep.name]
+        except KeyError:
+            continue  # it's not a message package
+        gradle_dependency_string += "compile 'org.ros.rosjava_messages:" + dependency_package.name + ":" + dependency_package.version + "'\n"
+    return gradle_dependency_string
+
+
+def create_msg_package_index():
+    """
+      Scans the package paths and creates a package index always taking the
+      highest in the workspace chain (i.e. takes an overlay in preference when
+      there are multiple instances of the package).
+
+      :returns: the package index
+      :rtype: { name : catkin_pkg.Package }
+    """
+    # should use this, but it doesn't sequence them properly, so we'd have to make careful version checks
+    # this is inconvenient since it would always mean we should bump the version number in an overlay
+    # when all that is necessary is for it to recognise that it is in an overlay
+    # ros_paths = rospkg.get_ros_paths()
+    package_index = {}
+    ros_paths = rospkg.get_ros_package_path()
+    ros_paths = [x for x in ros_paths.split(':') if x]
+    for path in reversed(ros_paths):  # make sure we pick up the source overlays last
+        for unused_package_path, package in find_packages(path).items():
+            if 'message_generation' in [dep.name for dep in package.build_depends]:
+#                 print(package.name)
+#                 print("  version: %s" % package.version)
+#                 print("  dependencies: ")
+#                 for dep in package.build_depends:
+#                     if not (dep.name == 'message_generation'):
+#                         print("         : %s" % dep)
+                package_index[package.name] = package
+    return package_index
+
+
+def create(msg_pkg_name, output_dir):
+    '''
+    Creates a standalone single project gradle build instance in the specified output directory and
+    populates it with gradle wrapper and build.gradle file that will enable building of the artifact later.
+
+    :param str project_name:
+    :param dict msg_package_index:  { name : catkin_pkg.Package }
+    :param str output_dir:
+    '''
+    if os.path.exists(output_dir):
+        shutil.rmtree(output_dir)
+    genjava_gradle_dir = os.path.join(output_dir, msg_pkg_name)
+    os.makedirs(genjava_gradle_dir)
+    msg_package_index = create_msg_package_index()
+    if msg_pkg_name not in msg_package_index.keys():
+        raise IOError("could not find %s on the ros package path" % msg_pkg_name)
+
+    msg_dependencies = create_dependency_string(msg_pkg_name, msg_package_index)
+
+    create_gradle_wrapper(genjava_gradle_dir)
+    pkg_directory = os.path.dirname(msg_package_index[msg_pkg_name].filename)
+    msg_pkg_version = msg_package_index[msg_pkg_name].version
+    populate_project(msg_pkg_name, msg_pkg_version, pkg_directory, genjava_gradle_dir, msg_dependencies)

src/genjava/templates/genjava_project/build.gradle.in

+/*
+ * Copyright (C) 2014 %(author)s
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+task wrapper(type: Wrapper) {
+    gradleVersion = '1.11'
+}
+
+buildscript {
+    def rosMavenPath = "$System.env.ROS_MAVEN_PATH".split(':').collect { 'file://' + it }
+    def rosMavenRepository = "$System.env.ROS_MAVEN_REPOSITORY"
+    repositories {
+        rosMavenPath.each { p ->
+            maven {
+                url p
+            }
+        }
+        mavenLocal()
+        maven {
+            url rosMavenRepository
+        }
+    }
+    dependencies {
+        classpath group: 'org.ros.rosjava_bootstrap', name: 'gradle_plugins', version: '[0.1,0.2)'
+    }
+}
+
+apply plugin: 'ros-java'
+group 'org.ros.rosjava_messages'
+version = '%(project_version)s'
+
+ext {
+    generated_sources_directory = "${projectDir}/src/main/java"
+}
+
+task generateSources (type: JavaExec) {
+    description = "Generate sources for %(project_name)s"
+    outputs.dir(file(generated_sources_directory))
+    args = new ArrayList<String>([generated_sources_directory, '--package-path=%(pkg_directory)s', '%(project_name)s'])
+    classpath = configurations.runtime
+    main = 'org.ros.internal.message.GenerateInterfaces'
+    tasks.compileJava.source outputs.files
+}
+
+dependencies {
+  compile 'org.ros.rosjava_bootstrap:message_generation:[0.1,)'
+  %(msg_dependencies)s
+}
+
+task info << {
+    println "\nProject Info"
+    println "============\n"
+    println "Name          : ${rootProject}"
+    println "Dir           : ${projectDir}"
+    println "Group         : ${group}"
+    println "Version       : ${version}"
+    println "Configurations: " + configurations
+
+    println "\nPackage Info"
+    println "============\n"
+    println "Name          : %(project_name)s"
+    println "Dir           : %(pkg_directory)s"
+
+    println "\nGenerate Info"
+    println "============\n"
+    println "Output Dir    : ${generated_sources_directory}"
+    println "Task Args     : " + tasks["generateSources"].args
+    tasks["generateSources"].outputs.getFiles().getAsFileTree().each {
+        println "Files         : ${it}"
+    }
+}
+
+defaultTasks 'publishMavenJavaPublicationToMavenRepository'