class Pie
  def initialize(name, age)
    @name = name
    @age = age
  end
  def to_s
    @name
  end
  def age
    @age
  end
 end
 
 #Age is saved in seconds
 
 SECOND = 1
 MINUTE = 60 * SECOND
 HOUR = 60 * MINUTE
 DAY = 24 * HOUR
 WEEK = 7 * DAY
 
 
 first_pie = Pie.new "Torta de Ameixa da Vovo", 6000
 
 def using(unit, &block)
  Pie.class_eval { alias_method :original_age, :age }
  Pie.send :define_method, :age do
    original_age / (Kernel.const_get unit.to_s.upcase)
  end
  yield
  Pie.class_eval { alias_method :age, :original_age }
 end
 
 using :second do
  puts "Seconds: #{first_pie.age}"
 end
 
 using :minute do
  puts "Minutes: #{first_pie.age}"
 end
 
 using :hour do
  puts "Hours: #{first_pie.age}"
 end


Como é possível identificar, cada bloco altera o comportamento do método ‘age’.
A maneira não é segura, nem muito boa para ser usada em produção, pois se ocorrer algum erro, é provavel que o método original se perca, mas é uma ótima forma de saber como a linguagem possui alguns recursos bem interessantes.

A imagem a baixo demonstra como criar/remover colunas, e um exemplo da migration gerada.

Comando rails para criar migration reponsável por adicionar coluna.

Com base na documentação do RSpec, consegui fazer o seguinte:
Spec::Matchers.define :list_friends do |count|
match do |my_contacts|
if count
my_contacts.select{|contact| contact.is_friend?}.size == count
else
my_contacts.any?{|contact| contact.is_friend?}
end
end
failure_message_for_should do |contacts|
if count
"expected that #{count} of your contacts were your friends"
else
"expected that any of your contacts were your friend"
end
end
failure_message_for_should_not do |contacts|
if count
"didn't expected that #{count} of your contacts were your friends"
else
"expected that none of your contacts were your friend"
end
end
description do
"assure that you have any, many, or no friends"
end
end
Em uma aplicação rails, sugiro que salve o arquivo conforme o seguinte: spec/support/matchers/friends_matchers.rb

Solução limpa, bonita, que além de deixar seu teste mais elegante, auxiliará caso ocorra algum erro, especificando na própria mensagem o erro que ocorreu.

Porém, esse drama para mim acabou!

Alguns meses atrás, descobri uma ferramenta muito útil, que utilizo até hoje. O CLCL, é um programa que vai “guardando” a nossa área de transferencia. Cada vez que fazemos o famoso “Ctrl + C”, ele captura o que foi copiado e guarda. Por padrão, ele proporciona 30 “Ctrl + C”‘s, mas é possível configurar sem grandes problemas. Após copiar o objeto desejado, basta pressionar “Alt + C” para ter acesso a uma lista com as últimas coisas copiadas para a área de transferencia.
Normalmente utilizo com pequenos fragmentos de código, etc. Até hoje, só tive problemas com imagens, uma vez que, tentei capturar mais de 5, e ele não conseguiu recuperar da forma desejada.

As vezes, aquele trabalho de fazer “Ctrl + C”, “Alt + Tab”, “Ctrl + V”, “Alt + Tab”, “Ctrl + C”, “Alt + Tab”, “Ctrl + V”…, pode se tornar o seguinte: “Ctrl + C”, “Ctrl + C”, “Ctrl + C”, “Alt + Tab”, “Alt + C”, “Alt + C”, “Alt + C”

Embora não pareça muita vantagem, sinto uma agonia em ver 2 documentos ‘pulando’ na minha tela, e casos simples como esse são resolvidos com o uso do CLCL.

Após alguns dias de uso, o CLCL torna-se uma ferramenta indispensável não só no desenvolvimento de software, mas também em consultas acadêmicas, montagem de documentos, entre outros.

A princípio, seu uso estaria envolvido apenas na rede interna de uma empresa, porém decidi que utilizaria algumas regras na validação de usuários, para saber quem movimentou o que, quando, etc…
Para me auxiliar nisso, instalei o plugin Spring-Security-Core. Resolvi por utilizar a anotação @Secured nos meus controllers, para poder validar o que poderia ser alterado por usuários(movimentação em geral), e o que poderia ser alterado pelo administrador(master data, assim como as devidas permissões aos usuários).

Com uma rápida vasculhada pelo guia disponibilizado por eles, seguindo o tutorial, encontrei algo semelhante ao seguinte:
package a.b.c
import grails.plugins.springsecurity.Secured
@Secured(['ROLE_ADMIN'])
class MeuQueridoController { ... }

Porém, ao utilizar este recurso do plugin desta forma, ocorria o seguinte erro:
Exception Message: EL1008E:(pos 0): Field or property 'ROLE_ADMIN' cannot be found on object of type 'org.springframework.security.web.access.expression.WebSecurityExpressionRoot'
Caused by: Failed to evaluate expression 'ROLE_ADMIN'
Acredito que foi apenas um erro nestes documentos do plugin, pois vasculhando no mesmo, encontramos o código contendo a informação correta, podemos corrigir o erro da seguinte forma:
package a.b.c
import grails.plugins.springsecurity.Secured
@Secured(["hasRole('ROLE_ADMIN')"])
class MeuQueridoController { ... }

Buscando um pouco na documentação do Spring, cheguei no seguinte:
org.springframework.security.web.access.expression.WebSecurityExpressionRoot
que por sua vez, herda os seguintes métodos da classe SecurityExpressionRoot:
boolean denyAll()
boolean hasAnyRole(java.lang.String... roles)
boolean hasRole(java.lang.String role)
boolean isAnonymous()
boolean isAuthenticated()
boolean isFullyAuthenticated()
boolean isRememberMe()
boolean permitAll()

A partir disso, temos o controle desejado de nossos usuários na aplicação de diversas formas, passando basicamente a condição para acesso:

Liberando para duas “classes” de permissões:
@Secured("hasAnyRole(['PERMISSAO_DE_ADMINISTRADOR','PERMISSAO_DE_USUARIO'])")

Liberando acesso apenas para usuários que não estejam logados:
@Secured("isAnonymous()")

Acesso para qualquer usuário, bastando apenas estar logado.
@Secured("isAuthenticated()")

Com base nisso, podemos facilmente controlar o acesso de toda a aplicação.

Este post será útil aqueles que ainda não estão familiarizados com Groovy em si, ou alguns de seus frameworks.

Antes de qualquer coisa, não seria bom conhecer um pouco a respeito da linguagem?

Basicamente, Groovy é uma linguagem dinâmica*, que roda na JVM*, que pode fazer uso de todas as bibliotecas já existentes em java*. Ela também simplifica o trabalho do desenvolvedor em testes unitários*, assim como na criação de aplicações desktop e web, e possui suporte à DSL’s*. Com este breve resumo já somos capazes de entender o suficiente sobre ela.

*Dinâmica: A começar pela Tipagem, uma linguagem fortemente tipada é uma linguagem na qual devemos declarar os tipos(se é inteiro, string, etc), já na linguagem dinâmica, não precisamos fazer isso, basta criar uma variável, que poderá ser qualquer coisa. A tipagem também pode ser estática(em tempo de compilação) ou em tempo de execução. Outro ponto interessante do Groovy, é o possibilidade de executar o código diretamente ou compila-lo.

*JVM: É a máquina virtual java. Como já dizia o slogan da sun: “Write once, run anywhere“, código que fazemos em java, após ser compilado, é interpretado não pelo computador que irá roda-lo, mas sim pela JVM presente naquele computador, que será capaz de executar o código então na máquina. Isso nos garante que o código que criamos rodará em qualquer plataforma, desde que a mesma possua suporte a java(Windows, Unix, MacOS, Aparelhos celulares, etc, java está presente em quase tudo).

*Bibliotecas java: Hoje podemos encontrar milhares de projetos java, que fornecem diversas funcionalidades, desde um framework para desenvolvimento web completo, até um simples(nem tão simples) validador de cpf. Grande parte dessas bibliotecas foram criadas para utilização com java, e sendo Groovy uma linguagem que roda na JVM, nós podemos utilizar todo e qualquer recurso que é fornecidor por essas bibliotecas, isso garante ao groovy um enorme leque de possibilidades.

*Testes unitários: Podemos dizer que testes são uma ferramenta para o desenvolvedor garantir a funcionalidade do seu código. Através de testes unitários, podemos verificar resultados da execução de um método, entre outros.

*DSL’s: Conhecidades como ‘Domain Specific Languages’, são linguagens específicas para algum contexto. Por exemplo, trabalhando em um banco, é possivel criar uma linguagem própria do banco, que teria funcionalidades do próprio negócio, como acesso a contas, verificação de saldo, movimentação, etc.

O papo está bom, mas vamos deixar de enrolação, e vamos instalar o groovy!

Caso utilize Windows, e esteja com preguiça, você pode baixar o windows-installer, que fará todo o trabalho sujo por você,

caso contrário, pode seguir o guia abaixo para windows:

1. Baixe o Binary Release do Groovy
2. Descompacte onde achar mais conveniente, eu descompactei em C:/groovy-1.7.1/
3. Agora vamos direcionar a sua variável de ambiente GROOVY_HOME para a pasta recém criada:

• Clique com o botão direito em Meu Computador, Acesse a opção Propriedades.
• Selecione a opção Avançado. Na aba avançado, clique em Variáveis de Ambiente(environment variables).
• Após isso, é possível criar a variável de ambiente GROOVY_HOME com a pasta que recém descompactamos:
• Depois de criar a variável de ambiente GROOVY_HOME precisamos adicionar na variável PATH o seguinte: %GROOVY_HOME%\bin, separando das demais variáveis com ponto e vírgula(;).
• Você também deverá possuir uma JDK instalada.
• Possuindo a JDK instalada, verifique se a váriavel JAVA_HOME já existe, caso não exista, crie-a assim como criamos a variável GROOVY_HOME, porém desta vez, utilizando o caminho da instalação da JDK.

Observação Importante: Note que criamos a variável GROOVY_HOME na parte de variáveis do sistema(System variables), e não acima(de usuário, User variables for gregorio), então é importante frisar que as variáveis PATH e GROOVY_HOME contendo a configuração criada, deverão estar ambas ou na parte do usuário, ou na parte do sistema. Minha sugestão é que criem para o sistema.

Em qualquer outro sistema operacional, o necessário para a instalação são os 3 paths vistos acima, GROOVY_HOME, JAVA_HOME e PATH.

Após configurado, podemos enfim, meter a mão no código!

Na linha de comando, podemos executar o seguinte comando:
groovysh

Este é um simples shell onde podemos executar código groovy, sem qualquer impedimento.

Aproveitamos então, para fazer nosso tão esperado ‘Hello World!’… basta digitar o seguinte:

println 'Hello World!'

Após isso temos o seguinte resultado:

Até a próxima!