Tipos de Scaffold com Grails

No último sábado, dia 17/09/2011 fizemos um HandsOn do JUGMS com Groovy 1.8 e Grails 2.0.0.M2. Vimos desde o básico, começando com um overview de Groovy e depois vendo o basicão de Grails. Como muitas dessas coisas não é muito dificil de conseguir ver na net, vou focar em coisas que nesse momento agregam um pouco mais de valor. Aí sim, depois que postar as coisas menos fáceis de achar na net, posso postar um projeto desde o início. Mas até lá (se esse lá chegar) tem um monte de vídeo bacana na net com esse início.

Uma coisa bacana dessas ferramentas modernas como RoR, Grails, Roo, e mais um monte, é o scaffold. Mas apesar de ser meio carne de vaca, vou tentar falar disso mostrando umas coisinhas a mais.



Scaffold

Esse conceito foi copiado da engenharia civil, e quer dizer andaime. Eles servem para sustentar os trabalhadores enquanto a estrutura final não está pronta, ou seja, é algo temporário, um quebra galho.
Na programação é a mesma coisa… uma estrutura temporaria que serve para que possamos nos focar no mais importante em vez de ficar metade do tempo do projeto enfeitando CRUD. Ao mesmo tempo que os scaffolds são massa pra caramba numa primeira olhada, logo depois começamos a passar uma certa raiva com o código gerado, pois mais cedo ou mais tarde temos que mexer nesse código. Bom, para lidar melhor com isso vamos dar uma olhada em três formas de scaffold que podemos usar com o Grails.

Para mostrar um código mais próximo do real vou usar como exemplo o projeto jugmotors (criado no HandsOn) e suas respectivas classes de domínio.



1. Scaffold estático

Esseé o mais basicão de todos. É o que conseguimos ao executar

grails genereate-all jugmotors.Pedido

Isso gera o controlador PedidoController e as views correspondentes às operações de CRUD.
Ponto positivo: o código está ali, pronto para você customizar
Ponto negativo: se você mudar a domain class o CRUD vai ficar desatulizado, faltando campos, e aí vem erro ao salvar por campos requeridos não estarem na tela, etc.



2. Scaffold dinâmico

Em vez de gerar tudo, só crie um controlador assim:

class ModeloController {
    static scaffold = true
}

Nesse caso, como o controlador tem o mesmo nome (fora o sufixo) que a domain class Modelo, automaticamente será gerado todo o scaffold em tempo de execução. Se o controlador não tivesse o mesmo nome, você teria o mesmo efeito com:

class AlgumNomeController {
    static scaffold = Modelo
}

O legal é que a gente pode ir sobrescrevendo cada elemento do scaffold, como uma action do controlador ou então uma view do CRUD, ou só a show.gsp, ou só a list.gsp e assim sucessivamente.

Ponto positivo: você pode alterar livremente a classe de domínio que o scaffold se adapta automaticamente, pois não existe um código “físico” executando.
Ponto negativo: se não tivermos outro scaffold estatico gerado para ter noção do código que vai ser executado, acabamos ficando vendidos, pois não vemos o código. Pelo mesmo motivo, quando formos sobrescrever algum elemento do scaffold, podemos esquecer algum passo importante.



3. Install-templates

Tá certo que esse não chega a ser um tipo de scaffold, mas executando

grails install-templates

A gente ganha os pontos positivos do scaffold estatico e do dinâmico. Tanto o código gerado no scaffold estático, quanto o que executa no dinâmico (apesar de não vermos) veem dos templates. Esses templates ficam dentro da instalação do grails, mas quando executamos esse script copiamos ele para dentro do projeto. A partir de então, toda vez que mandarmos o grails fazer alguma coisa, como gerar um controlador, view ou mesmo um scaffold inteiro, ele vai usar o template do projeto, e não do grails. Obviamente ele primeiro olha no projeto e se não encontrar vai para o grails.

No projeto jugmotors, eu fiz um scaffold estático sem customização: pedido; e um customizado: modelo.

O CRUD de pedido eu deixei como foi gerado, mas o de modelo eu fiz umas mudanças simples só para exemplificar a customização dos templates. Na view list.gsp eu coloquei as mesmas opções presentes na view show (editar e deletar). Então em vez da listagem padrão que só tem um link para a visualização, agora temos um botão que manda direto para e edição e um que apaga.

Depois de ter customizado essa tela, eu voltei para o código do template list.gsp e coloqui o mesmo estilo nele (não que esteja bom ou bonito, a ideia é exemplificar).

Agora se executarmos o CRUD de opcional, que é dinâmico, vemos que fica bem parecido com o de modelo. Agora se eu executar

grails generate-all <domain class>

O código gerado já vai sair de acordo com o meu novo template. Isso é muito legal, pois não temos que ficar “reféns” do código gerado pelo framework, pois agora o código é meu.

Ponto positivo: Tanto o scaffold estático quanto o dinâmico respeitam o nosso template :)
Ponto negativo: A gente vai ter um pouco mais de trabalho para fazer um template do que para fazer um arquivo comum, seja um gsp ou um groovy. Isso porque temos que prestar atenção nas expressões que escrevem outas expressões… então temos que usar muito escape. Exemplo simples do template list.gsp:

<g:link class="edit" action="edit" id="\${${propertyName}.id}">Editar</g:link>

Aqui no caso a propertyName se refere ao nome da propriedade do g:each que itera todos os objetos. Supondo que em tempo de execução propertyName seja igual a “pedidoInstance”, o resultado seria:

<g:link class="edit" action="edit" id="${pedidoInstance.id}">Editar</g:link>

Espero que a partir de agora a gente use mais essa funcionalidade de instalar os templates e assim customizá-los. E apesar de eu ter colocado somente o exemplo de customização de template de uma view, navegando dentro da pasta src/templates do projeto podemos ver os templates usados para criar classes de domínio, controladores, filtros, testes, etc. Logo, templates não são apenas para scaffold.

Mas pessoal, lembre do conceito do scaffold. A idéia é te entregar algo resoável para trabalharmos no mais importante. Então a menos que seja um CRUD muito sem vergonha é bom que você substitua o código gerado (mesmo customizado via template) pelo teu, que provavelmente vai ser melhor que o gerado.

One thought on “Tipos de Scaffold com Grails

  1. Pingback: HandsOn Groovy 1.8 e Grails 2.0 – JUGMS

Leave a Reply

Your email address will not be published. Required fields are marked *

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>