Migrating from ANT and IVY to Gradle

Related to the previous post, Migrating from Maven to Gradle, here are some things I found when attempting to migrate an ANT / IVY build to Gradle.

Advantages over ANT/IVY

• XML is not for humans - Gradle's DSL is much more readable and more concise.   No need for 'ivy.xml' and 'build.xml' and tons of 'properties files'.
• Conventions -  Avoid re-inventing the wheel.   If you use the conventions for the Gradle plugins, this eliminates a great deal of code and makes your project look 'normal' to other people.  They can just dive right in and be productive.  "You are not special"  ;)
• Declarative - Gradle is more declarative and eliminates a ton of boring, boilerplate code compared to ANT.
• Plugins - Eliminate even more boilerplate code, and gain some conventions. 
• Get dependencies.
• Compile  the main code and the test code.  Process any resources.   Compile dependencies (multi-module).
• Run the test suite and generate reports.
• Jar up the main code.
• Self install - Gradle self-installs from VCS via the gradle wrapper.
• 'one kind of stuff' - Dependencies are declared right in the build file.
• Daemon mode!

Getting started

• Add build.gradle and settings.gradle to the root directory.   Can be empty files at first.
• Gotcha #1: If you are using Subversion with the standard layout, Gradle will think that the project is named 'trunk' (or whatever the branch directory is... Subversion really sucks at branches!).
  
  To fix this, simply add rootProject.name='the-real-project-name' in settings.gradle.
• Re-open the IDEA project.  IDEA will import the gradle project.
  Eclipse probably has something similar.
• For a Java project, apply the Java plugin in build.gradle: apply plugin: 'java'
  This will automatically add the expected tasks for compiling, running tests, packaging as a jar, etc.  You don't have to write this boring stuff!
• Custom source locations - Let's say the project has the sources in src and test_src.  This is not the standard layout for the java plugin, so we'll need to configure that in build.gradle:
  
  

  sourceSets {
      main {
          java {
              srcDir 'src'
          }
          resources {
              srcDir 'conf'
          }
      }
      test {
          java {
              srcDir 'test_src'
          }
      }
  }
  

• Now we need to add the dependencies.   Since Gradle is based on Groovy, it's easy to make a simple converter:
  

  task convertIvyDeps << {
      def ivyXml = new XmlParser().parse(new File("ivy.xml"))
  
      println "dependencies {"
      ivyXml.dependencies.dependency.each {
          def scope = it.@conf?.contains("test") ? "testCompile" : "compile"
          println("\t$scope \"${it.@org}:${it.@name}:${it.@rev}\"")
      }
      println "}"
  }
  

  
  Just run the task and paste the output into the dependencies closure.
  
  We can also do something more radical: Parse the ivy.xml and populate the dependencies that way, see this post.
•  Gocha #2: If you are using a properties file to define versions in ivy.xml, this will be a little different in Gradle.
• Gradle supports 'extra properties' typically defined in an 'ext' closure.   These can be referenced inside double quoted strings in the dependencies closure.
• Gradle doesn't like dots in the extra property names.   I changed them to underscore.  For example:
  

  ext {
    version_junit="4.11"
  }
  
  dependencies {
     ... blah blah blah...
     testCompile "junit:junit:${version_junit}"
  }
  

• It's nice having everything defined in one place. :)
• At this point, you have a basic build with compilation, testing, test reports, and all that.