Guilherme Garnier

Desenvolvimento de software e Open Source

Ferramentas para avaliação de qualidade de código Ruby

Ferramentas para avaliar a qualidade do seu código existem aos montes, para qualquer linguagem de programação. Eu já utilizei algumas para Java, mas nunca tinha testado nenhuma para Ruby, apesar de ser a linguagem que mais uso há alguns anos. Por isso, resolvi testar todas as ferramentas que pude encontrar. Separei a avaliação entre serviços e ferramentas.

Serviços

Classifiquei como serviços as ferramentas onde, em vez de instalar e executar localmente, você libera acesso ao seu repositório de código a elas, que coletam métricas a partir do código e geram algum relatório. Os dois serviços que avaliei são gratuitos para projetos open source e pagos para projetos com código fechado.

Code Climate

Este é certamente o serviço mais conhecido para avaliação de qualidade de código Ruby. Seu foco principal é gerar métricas baseadas em complexidade de código, mas ele também é capaz de identificar algumas falhas de segurança e cobertura de código dos testes.

Coveralls

O Coveralls funciona de forma semelhante ao Code Climate, porém tem um foco maior em testes. Ele exibe o histórico de cobertura e a diferença para cada arquivo a cada commit.

Ferramentas

As ferramentas abaixo são open source e distribuídas através de gems. Para utilizá-las, basta instalar a gem e executar um comando, que analisa o código e gera relatórios ou dados brutos para serem analisados.

Brakeman

O Brakeman é uma ferramenta focada em localizar potenciais falhas de segurança no seu código. Ele também exibe alertas especificamente relacionados ao Rails, como falhas de segurança que já foram corrigidas numa versão do Rails mais recente do que a que você usa.

Como ele tem foco em segurança, é muito importante manter esta gem sempre atualizada, para que ele possa detectar falhas descobertas mais recentemente.

RuboCop

O foco do RuboCop é localizar más práticas de programação no seu código, com base no Ruby Style Guide. Algumas das regras são: uso de aspas simples ou duplas para definir strings, tamanho máximo da linha, número de linhas em cada método e uso de espaços na definição de hashes.

Todas as regras do RuboCop podem ser configuradas ou desabilitadas. Basta criar um arquivo .rubocop.yml na raiz do projeto com as configurações desejadas. Ele também possui regras específicas para projetos usando Rails.

Se você usa o editor Atom, também é possível executar o RuboCop automaticamente com o plugin atom-lint. Assim, ao salvar um arquivo, o RuboCop é automaticamente executado, e os alertas são exibidos no próprio editor, ao lado de cada linha.

RubyCritic

O RubyCritic foi criado com o objetivo de se tornar uma alternativa gratuita ao Code Climate. Ele gera um relatório bem semelhante ao deste serviço, reportando os trechos mais complexos do seu código.

Metric Fu

O Metric Fu é um agregador de ferramentas de análise de código. Ele executa diversas ferramentas e gera uma página com links para os resultados de cada uma. É uma das ferramentas mais completas para análise de código Ruby, e uma das mais antigas.

Ruby-lint

O foco do Ruby-lint é localizar erros como variáveis não utilizadas ou não inicializadas, ou número errado de argumentos ao executar um método. O problema é que quando extendemos ou incluimos classes ou módulos definidos fora do projeto (em gems), ele não encontra as dependências e dá erro de constante indefinida. Apesar disso, parece que vem sendo bastante atualizado.

Reek

Esta ferramenta é um detector de bad smells no código, como Long Parameter List e Feature Envy. Possui plugins para rodar alguns editores, como Vim e TextMate.

Roodi

Roodi significa “Ruby Object Oriented Design Inferometer”. Ele executa algumas métricas de complexidade de código, mas é bem básico. A maioria das métricas já são calculadas por outras ferramentas apresentadas aqui.

Flog

Gera um score baseado na complexidade de código. Bem básico.

Rails Best Practices

Ferramenta bem útil, gera métricas de qualidade baseadas no Rails Best Practices. Como diz o nome, é específico para projetos Rails. Também é disponibilizado como um serviço online gratuito, mas somente para projetos públicos no Github. Para projetos privados, é possível instalar uma instância própria, pois o servidor é open source.

Cane

Mais um gerador de métricas de qualidade. As métricas são parecidas com as do RuboCop.

Pelusa

Este projeto é semelhante ao Ruby-lint, mas não consegui executar. Ele só funciona com Rubinius, mas é incompatível com a versão mais recente (apesar de o projeto não informar quais são as versões compatíveis).

Flay

Esta ferramenta procura similaridades na estrutura do seu código (ex: dois métodos que possuem o código muito semelhante).

Saikuro

Gera métricas de complexidade ciclomática.

Laser e Nitpick

Mais duas ferramentas semelhantes ao Ruby-lint. Como estão há anos sem atualizações, nem testei.

Resumindo…

Entre as ferramentas que testei, gostei mais do Brakeman, do RuboCop e do RubyCritic. Acredito que são complementares, e, se usadas em conjunto, ajudam bastante a encontrar falhas de segurança, os pontos mais complexos do seu código e a seguir boas práticas de programação Ruby.

Além destas 3, também gosto do Metric Fu, mas por executar muitas ferramentas, acho que ele gera informação demais. Usando ferramentas e métricas em excesso, geramos tanta informação que acabamos ignorando-as. Por isso, preferi focar nas 3 ferramentas que citei, pois já consigo ter um panorama bem completo do status do meu código com elas.

Usando na prática

Todas as ferramentas que testei são executadas via linha de comando e geram como saída algum tipo de relatório. Apesar de poder executá-las manualmente, na minha opinião, é mais interessante executá-las no servidor de integração contínua (CI). Desta forma, garantimos que essas ferramentas serão executadas com frequencia, e todo o time tem acesso aos relatórios gerados, assim como gráficos de evolução a cada execução. Com isso, podemos analisar se a “saúde” do projeto está melhorando ou piorando, basta acompanhar se o número de warnings de uma determinada ferramenta estão aumentando ou diminuindo.

No caso específico do RuboCop, como ele analisa o uso de boas práticas de programação, acho mais útil executar no editor, pois, ao salvar um arquivo, tenho a resposta imediata, e posso fazer os ajustes no mesmo momento. Mas isso é uma questão de preferência.

Executando no Jenkins

Como uso o Jenkins, descrevi como configurar as ferramentas acima neste servidor. O processo é bem simples, acredito que não seja difícil reproduzí-lo em outros servidores de integração contínua.

Cada ferramenta pode ser executada por um job à parte ou no mesmo job que roda o build e os testes do projeto. Optei pela 1a opção, por 2 motivos:

  1. O tempo de execução de cada ferramenta de análise de código pode ser razoavelmente longo, o que deixaria o job de build muito lento
  2. Caso ocorra algum problema na execução de alguma destas ferramentas, não quero que o job de build do meu projeto apareça quebrado no CI. Se o build e todos os testes foram executados com sucesso, o job que executa o build deve ter sucesso

Além disso, optei por instalar as gems diretamente no CI. Desta forma, além de não precisar configurá-las no Gemfile do projeto, garanto que as gems estarão sempre atualizadas, o que é muito importante, principalmente no caso do Brakeman, pois novas falhas de segurança são encontradas diariamente.

Criando um novo job

Ao criar um novo job no Jenkins, você pode configurá-lo para executar automaticamente após cada build do projeto ou para executar periodicamente. Apesar de a primeira opção garantir que os relatórios de análise de código estarão atualizados a cada build, a execução é um pouco demorada. Além disso, achei que um relatório por dia seria suficiente para acompanhar o status do projeto. Sendo assim, configurei o job de relatórios para executar diariamente, de segunda a sexta-feira. Para isso, na configuração do job, basta selecionar a opção Build periodically, e no campo Schedule, digitar H 0 * * 1-5, por exemplo (o formato é o mesmo usado no crontab). Este valor configura o job para ser executado em qualquer minuto da hora zero, em qualquer dia do mês, todos os meses, de segunda a sexta-feira (dias 1 a 5).

Eu optei por criar um único job para executar todas as ferramentas, pois desta forma, tenho todos os relatórios centralizados num único local. A principal desvantagem é que, desta forma, um erro na execução de uma ferramenta fará o job encerrar com status de erro, e as ferramentas seguintes não serão executadas.

Para configurar cada ferramenta dentro do job, o processo é o mesmo:

  1. Selecionar em Build a opção Execute shell, com os comandos para instalar e executar a gem
  2. Adicionar uma Post-build Action para exibir os resultados

A configuração de cada ferramenta é a seguinte:

Brakeman

Configure a execução da ferramenta digitando os seguintes comandos no campo Execute shell da configuração do job:

1
2
mkdir -p tmp
gem install brakeman --no-ri --no-rdoc && brakeman -o tmp/brakeman-output.tabs --no-progress --separate-models --quiet

Para visualizar os resultados, instale o Brakeman Plugin no Jenkins e selecione em Post-build Actions a opção Publish Brakeman warnings. Em Brakeman Output File, digite tmp/brakeman-output.tabs.

RubyCritic

Adicione o seguinte comando no campo Execute shell:

1
gem install rubycritic --no-ri --no-rdoc && rubycritic app lib

Para visualizar os resultados, é necessário o plugin HTML Publisher. Após instalá-lo, selecione em Post-build Actions a opção Publish HTML reports e digite os seguintes valores:

  • HTML directory to archive: tmp/rubycritic
  • Index page[s]: overview.html
  • Report title: RubyCritic Reports

RuboCop

Digite os comandos abaixo no campo Execute shell:

1
2
mkdir -p tmp
gem install rubocop --no-ri --no-rdoc && rubocop --fail-level E --rails --out tmp/rubocop.out app lib spec

O plugin para exibir o resultado desta ferramenta é o Warnings. Após instalá-lo, é necessário configurar um parser para os warnings do RuboCop. Vá até a configuração do Jenkins (Manage Jenkins –> Configure System). Em Compiler Warnings, adicione um novo parser com os seguintes valores:

  • Name: RuboCop
  • Link name: RuboCop
  • Trend report name: RuboCop Warnings
  • Regular Expression:
1
^([^:]+):(\d+):\d+: ([^:]): ([^:]+)$
  • Mapping Script:
1
2
3
4
5
6
7
8
import hudson.plugins.warnings.parser.Warning

String fileName = matcher.group(1)
String lineNumber = matcher.group(2)
String category = matcher.group(3)
String message = matcher.group(4)

return new Warning(fileName, Integer.parseInt(lineNumber), "RuboCop Warnings", category, message);
  • Example Log Message:
1
attributes/default.rb:21:78: C: Use %r only for regular expressions matching more than 1 '/' character.

Após salvar esta configuração, volte até a configuração do job e selecione em Post-build Actions a opção Scan for compiler warnings. Em File pattern digite tmp/rubocop.out, e no campo Parser, selecione o parser recém-criado, RuboCop.

Abril Pro Ruby 2014: links para as apresentações

Na última semana aconteceu o evento Abril Pro Ruby 2014, em Porto de Galinhas. O evento foi excelente, muito bem organizado e com várias palestras e workshops de excelente nível técnico.

No dia de palestras, fiz uma apresentação sobre Arquitetura Distribuída, onde mostrei uma pequena parte da arquitetura do projeto Globotv.

Os vídeos das apresentações foram disponibilizados no Youtube. Seguem abaixo os links para cada apresentação e workshop. Alguns estão faltando, mas assim que conseguir, eu atualizo os links do post.

Apresentações:

Workshops:

Variáveis de classe e de instância de classe em Ruby

Por ser uma linguagem orientada a objetos, Ruby possui variáveis de instância e de classe. As primeiras se referem a cada instância de uma determinada classe e as segundas à própria classe:

1
2
3
4
5
6
7
8
9
10
11
class Funcionario
  @@dias_de_ferias = 30

  def salario=(valor)
    @salario = valor
  end

  def salario
    @salario
  end
end

Como esperado, cada instância da classe Funcionario possui uma instância da variável @salario, e a variável @@dias_de_ferias possui uma única instância:

1
2
3
4
5
6
7
8
9
Funcionario.class_variable_get(:@@dias_de_ferias)  # 30

funcionario1 = Funcionario.new
funcionario1.salario = 2000
funcionario1.salario  # 2000

funcionario2 = Funcionario.new
funcionario2.salario = 2500
funcionario2.salario  # 2500

Até aqui nada de novo. Porém, um tipo de variável menos conhecida e usada é a variável de instância de classe.

Como tudo em Ruby é um objeto, todas as classes (tanto as classes padrão do Ruby quanto as criadas pelo usuário) são objetos – instâncias da classe Class:

1
2
3
String.class  # Class

Funcionario.class  # Funcionario

E, como são objetos, as classes também podem ter variáveis de instância. Para definí-las e acessá-las, basta prefixar o nome da variável com “@”, da mesma forma como é feito com variáveis de instância, porém no escopo de classe (ou num método de classe):

1
2
3
4
5
6
7
class Funcionario
  @bonus = 1000

  def self.atualiza_bonus
    @bonus = 2000
  end
end

O comportamento de variáveis de instância de classe é semelhante às variáveis de classe, com uma diferença: quando usamos herança, as variáveis de classe são compartilhadas entre todas as classes da hierarquia, e as variáveis de instância de classe tem uma instância para cada classe:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Funcionario
  @@dias_de_ferias = 30
  @bonus = 1000
end

class Gerente < Funcionario
  @bonus = 5000
end


Funcionario.class_variable_get(:@@dias_de_ferias)  # 30
Funcionario.instance_variable_get(:@bonus)  # 1000

Gerente.class_variable_get(:@@dias_de_ferias)  # 30
Gerente.instance_variable_get(:@bonus)  # 5000

Gerente.class_variable_set(:@@dias_de_ferias, 45)
Gerente.class_variable_get(:@@dias_de_ferias)  # 45
Funcionario.class_variable_get(:@@dias_de_ferias)  # 45

No exemplo acima, a variável de classe @@dias_de_ferias é compartilhada entre as classes Funcionario e Gerente. Por isso, ao alterar o valor desta variável na subclasse, o valor na superclasse também mudou. Para confirmar que a instância é a mesma, basta verificar que o object_id da variável em ambas as classes:

1
2
Funcionario.class_variable_get(:@@dias_de_ferias).object_id  # 70139308064800
Gerente.class_variable_get(:@@dias_de_ferias).object_id  # 70139308064800

No caso da variável de instância de classe @bonus, há uma instância para a classe Funcionario e outra para a classe Gerente:

1
2
Funcionario.instance_variable_get(:@bonus).object_id  # 70139307998300
Gerente.instance_variable_get(:@bonus).object_id  # 70139308064780

Minha palestra no FISL 14 - Design Patterns em Ruby

Na última semana aconteceu a última edição do FISL, o Fórum Internacional de Software Livre. No segundo dia do evento, fiz uma palestra sobre Design Patterns em Ruby, a qual foi baseada neste post. Todas as palestras do evento foram transmitidas ao vivo, e os vídeos já estão disponíveis.

Disponibilizei o vídeo da minha apresentação no Vimeo e os slides no Slideshare.

UPDATE: atualizei os slides após apresentar esta mesma palestra no evento RS on Rails.

Design patterns em Ruby - Decorators, Presenters e Exhibits

Ao criar um novo projeto Rails, o generator cria uma estrutura padrão de diretórios. Dentro de app, ele cria os diretórios models, controllers, views e helpers. Os três primeiros tem papéis bem definidos, mas mesmo assim há uma certa confusão quando surge algum arquivo “fora do padrão”.

Numa aplicação típica, um model geralmente estende a classe ActiveRecord::Base ou inclui um módulo, como Mongoid::Document, no caso do Mongoid, por exemplo, para mapear a estrutura do banco de dados. Além disso, o model contém as regras de negócio associadas a ele. O controller tem a responsabilidade de mapear a ação atual numa view – por exemplo, ao submeter um formulário para criação de um novo objeto, um controller típico renderiza uma view exibindo uma mensagem de sucesso, ou renderiza a mesma view do formulário com as mensagens de erro, caso haja algum. Já a view é responsável por exibir os dados correspondentes à página atual.

Essa estrutura básica funciona bem numa aplicação simples. O problema é quando a view começa a conter muita lógica. Por exemplo, uma view para exibir dados de um usuário poderia ser simples assim:

1
@usuario.nome

Porém, se o conteúdo muda dependendo do tipo de usuário (ex: usuário comum e admin), precisamos de um if dentro da view:

1
2
3
4
5
<% if @usuario.admin? %>
  admin
<% else %>
  @usuario.nome
<% end %>

Quando mais diferenças houver, mais complexa fica a view. Consequentemente, fica mais difícil de gerenciar. Além disso, normalmente fazemos testes unitários para o model e o controller, e testamos a view somente com testes de aceitação, que são muito mais lentos (é preciso carregar todo o ambiente, Rails, banco de dados, e dependendo do teste, abrir um browser). Fica impraticável testar todos os fluxos de uma view cheia de if’s usando testes de aceitação.

Uma solução comum no mundo Rails é usar os helpers. No exemplo acima, eu poderia ter o seguinte helper:

1
2
3
4
5
class UsuarioHelper
  def titulo_usuario(usuario)
    usuario.admin? ? "admin" : usuario.nome
  end
end

Isso deixa o código da view mais simples:

1
titulo_usuario(@usuario)

E, além disso, posso testar a lógica num teste unitário do helper. Mas essa solução também tem problemas: o helper não está associado diretamente ao objeto em questão. Isso ficou claro no exemplo acima, onde precisei passar o usuário como parâmetro para o método do helper. Isso se repetiria para cada método.

Uma boa solução para este caso é utilizar o design pattern Decorator. Para isso, criamos uma classe que recebe o model como parâmetro no construtor e implementa todos os métodos necessários para lógicas de visualização (ou seja, que não estão associados ao negócio e não devem ficar no model). Um exemplo de decorator é o seguinte:

1
2
3
4
5
6
7
8
9
10
11
class UsuarioDecorator
  attr_reader :usuario

  def initialize(usuario)
    @usuario = usuario
  end

  def titulo
    @usuario.admin? ? "admin" : @usuario.nome
  end
end

Outra opção é criar um decorator que também implementa o padrão Delegation. Neste caso, quando é chamado um método que não existe, o Decorator delega a chamada para o model. Segue um exemplo de implementação:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
module Decorator
  attr_reader :model

  def initialize(model)
    @model = model
  end

  def method_missing(meth, *args)
    if @model.respond_to?(meth)
      @model.send(meth, *args)
    else
      super
    end
  end

  def respond_to?(meth)
    @model.respond_to?(meth)
  end

  def self.included(base)
    base.extend(ClassMethods)
  end

  module ClassMethods
    def decorate(object)
      if object.is_a? Enumerable
        object.map {|obj| self.new(obj)}
      else
        self.new(object)
      end
    end
  end
end


class UsuarioDecorator
  include Decorator

  def titulo
    @model.admin? ? "admin" : @model.nome
  end
end

Desta forma, temos uma classe que recebe o model no construtor ou no método de classe decorate. A implementação do método titulo_usuario no Decorator ficou muito mais simples. Para utilizá-la, basta decorar o model no controller:

1
2
3
4
5
class UsuariosController
  def show
    @usuario = UsuarioDecorator.decorate(Usuario.find(params[:id]))
  end
end

A implementação da view fica assim:

1
@usuario.titulo

Em casos mais simples, o Decorator atende bem. Mas e quando temos uma página mais complexa, envolvendo diversos objetos? Precisaríamos criar um Decorator para cada model, e lembrar de decorar cada objeto na criação, assim como fizemos com o usuário no exemplo anterior. Outro problema é que podemos ter visualizações diferentes de um objeto em cada tela da aplicação. Como tratar este caso? Poderíamos criar métodos diferentes no Decorator, mas com o tempo o Decorator poderia virar um monstro. Outra opção é criar vários Decorators para aquele model, onde cada um se aplica a uma página. Ou podemos usar um outro padrão, o Presenter.

O Presenter é um padrão também conhecido por outros nomes, como View Object, mas na comunidade Ruby o nome Presenter se popularizou com um post de Jay Fields. O Presenter é muito parecido com o Decorator, mas envolve vários objetos. O contexto do Presenter é uma página específica da aplicação, e recebe como parâmetro todos os objetos necessários à exibição daquela página. Desta forma, toda a lógica de apresentação fica numa única classe. Segue um exemplo de uso do Presenter:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class PedidoPresenter
  def initialize(usuario, pedidos)
    @usuario = usuario
    @pedidos = pedidos
  end

  def titulo
    "Usuário #{@usuario.nome} - #{@pedidos.size} pedidos"
  end

  def links
    @pedidos.map { |pedido| link_to pedido.nome, pedido_url(pedido) }
  end
end

Ainda há uma outra opção além do Presenter, que foi apresentada no livro Objects on Rails. É o padrão Exhibit. A diferença em relação ao Presenter é que, enquanto o Presenter disponibiliza métodos para serem chamados pela view (como no exemplo acima), o Exhibit é responsável pela renderização. Para isso, ele precisa receber um contexto:

1
2
3
4
5
6
7
8
9
10
class Exhibit
  def initialize(obj, context)
    @obj = obj
    @context = context
  end

  def render_header
    @context.render :partial => "header", :locals => {:obj => @obj}
  end
end

Este contexto pode ser o view_context do controller:

1
2
3
4
5
class Controller
  def show
    @usuario = Exhibit.new(Usuario.find(params[:id]), view_context)
  end
end

Outra maneira de instanciar o Exhibit é através de um helper, como mostrado no livro The Rails View:

1
2
3
4
5
class Helper
  def exhibit
    Exhibit.new(Usuario.find(params[:id]), self)
  end
end

São muitos padrões que tem a mesma função: encapsular a lógica de visualização num único local, que seja facilmente testável. E qual é a melhor opção entre os três? A resposta depende da situação. Não adianta querer encontrar um padrão perfeito para todos os casos. Na minha opinião, o Decorator funciona bem em páginas mais simples, que envolvem apenas um model. Quando a página é mais complexa e envolve vários models, o Presenter e o Exhibit são mais adequados. E a diferença entre os dois é uma questão de gosto.

Links relacionados: