Gradle: um sistema de build MUITO agradável

Recentemente resolvi experimentar o Gradle em um projeto. Para aqueles que não o conhecem, trata-se de um sistema de build baseado em Groovy que trás a expressividade desta linguagem para o mecanismo de build, o que torna nossos scripts muito mais legíveis e fáceis de escrever. Sou fã do Ant, porém sempre me incomodou o fato de escrever meus scripts usando XML ao invés de uma linguagem estruturada.

Entre as principais vantagens que pude observar foram:

• Aprendizado mais fácil: como meus scripts são basicamente Groovy (que já conheço bem), tudo o que precisei aprender foram basicamente 3 coisas: como definir dependências, as tarefas default e uma ou outra task presente na API.
• Código mais fácil de ser compreendido: frequentemente me pego perdido em meus scripts do Ant conforme meus processos vão se tornando mais complexos.
• Escrita muito mais fácil: enquanto no Ant eu preciso ficar o tempo inteiro pesquisando a documentação em busca de quais tasks fazem o que, com Gradle tudo o que preciso consiste em escrever código Groovy.

Neste post irei expor o que já aprendi a respeito da ferramenta que, apesar de muito pouco, já supriu 100% das minhas necessidades.

Primeiro passo: instalação

Básicamente o mesmo processo de instalação do Groovy ou Grails.

1. Baixe os binários em http://gradle.org
2. Descompacte-os em um diretório de sua preferência
3. Crie uma variável chamada GRADLE_HOME que aponte para o diretório no qual se encontra a sua instalação
4. Adicione o diretório GRADLE_HOME/bin ao path do seu sistema.
5. Execute o comando gradle em sua linha de comando. Se aparecer uma mensagem diferente de “comando não encontrado”, você já pode começar a trabalhar.

Segundo passo: escrevendo seu primeiro script

Assim como no Apache Ant, o núcleo dos scripts de build do Gradle são as tarefas (que chamaremos daqui pra frente de tasks). O script mais bobo que podemos criar é o abaixo:

task bobagem << {

println "Sou uma bobagem"

}

Tudo o que estiver entre << { e } é código Groovy. Em nosso caso, a task irá simplesmente imprimir o texto “Sou uma bobagem” em nossa linha de comando.

Para executar o script, lembre-se de salvá-lo como build.gradle (é o nome default dos scripts usado pela ferramenta, mas pode ter também outros nomes, desde que você utilize o parâmetro -b seguido do nome do arquivo) e em seguida executar o comando gradle -q bobagem. O parâmetro -q indica qual task deverá ser executada.

Caso nenhum comando seja passado ao script, será exposta uma mensagem de erro nos informando de que não há uma task default definida em nosso script.

Como definir uma task padrão

Definir uma task padrão é muito simples. Basta incluir na primeira linha do seu script o seguinte comando:

defaultTasks 'bobagem'

Executando novamente o script (desta vez sem parâmetros) a task bobagem será executada.
Se você quiser, pode também definir uma sequência de tasks a serem executadas, tal como no exemplo abaixo:

defaultTasks 'bobagem', 'mais_bobagem'

Neste caso, a task bobagem será executada e, em seguida mais_bobagem.

Definindo dependências entre as tarefas

Se é um sistema de build, dependências devem poder ser definidas. Em nosso caso, é simples, tal como no exemplo abaixo:

defaultTasks: 'mais_bobagem'
task bobagem << {
  println "Sou boba"
}

task mais_bobagem(dependsOn: bobagem) <<
   println "Mas eu sou ainda MAIS boba!"
}

E a saída de nosso script será

Sou boba
Mas eu sou ainda MAIS boba!

Abusando do Groovy

E basicamente isto é tudo o que você precisa saber para começar a trabalhar. Para tornar a utilização do Gradle mais nítida, achei que seria interessante expor aqui um script que escrevi para fazer o backup de uma das minhas bases de dados:

defaultTasks 'backup'
def dataAtualString = {
	java.text.SimpleDateFormat formatadorData = new java.text.SimpleDateFormat("dd_MM_yyyy___hh_mm_ss")
	return formatadorData.format(new java.util.Date())
}

def arquivoBackupMySQL = {
	return file(diretorioBackup.getAbsolutePath() + "/gctbd_${dataAtualString()}.sql")
}

task backup << {
	println "Executando backup do MySQL..."
	def arquivoBackup = arquivoBackupMySQL()
	println "Gerando arquivo ${arquivoBackup.getAbsolutePath()}"
	"mysqldump -u loginQuente --password=quente --databases bd_quente >> ${arquivoBackup.getAbsolutePath()}".execute()
	println "Backup do MySQL executado com sucesso"

}

Repare que além da minha task backup tenho dois métodos: dataAtualString (que me retorna uma string contendo a data formatada) e arquivoBackupMySQL (que me retorna o arquivo aonde desejo salvar o meu backup.

Tudo o que preciso fazer consiste em chamar estes métodos assim como faria em Groovy dentro da minha task. Um processo muito mais simples do que aquele com o qual estava acostumado com Groovy.

Mas nem tudo são flores

Gradle ainda é novíssimo: pelo que pude ver, sua lista de discussão foi criada na segunda metade de 2008, e o projeto ainda está na sua versão 0.8 (nem logotipo direito possui!). Sendo assim, ainda é pouco conhecido e, consequentemente, possui bem menos material a seu respeito do que mecanismos mais tradicionais como o Apache Ant ou o (argh!) make.

Outro ponto negativo que encontrei foi a performance, que é bem aquém do Ant. No entanto, não tenho dados para comprovar esta queda na performance. Sendo assim, nada impede que trate-se apenas de impressão minha.

Tirando estes dois poréns (ambos temporários), acredito que o Gradle venha a se tornar cada vez mais popular como uma alternativa ao Ant pelo fato de adotar a linguagem Groovy como lingua franca. Recomendo!

PS:

sim, eu já conhecia o GANT, mas quis experimentar o Gradle para ver como era. :)