Analisando Complexidade de Código Ruby

Analisando Complexidade de
Código Ruby
Utilizando Métricas para Encontrar Código que Fede

Cássio Marques
RubyMasters Conf 2011

Saturday, February 26, 2011

Cássio Marques
• código + comida vegan + livros + skate +
música
• Taoweb
• Lime
• http://cassiomarques.wordpress.com
• @cassiomarques

Porque analisar o
código?


http://www.ﬂickr.com/photos/rovingi/312078231/

Como analisar o
código?


Estética


Diﬁculdade de
Manutenção


Chute


Abstrações


Métricas


Medir alguma
propriedade especíﬁca
do código


Objetivo: Quantiﬁcar o
que antes era abstrato


Métrica ABC


Analisa Complexidade


ﬂog
github.com/seattlerb/ﬂog


Assignement
Deﬁnir o valor de uma variável explicitamente


= +=
*= <<
/= etc...
-=


Branching
Criar um novo ﬂuxo de execução


if
or
else
rescue
elsif (argh!)
until
case
while
and


Calls
Chamadas a métodos


(Outras implementações usam Condition)


|ABC| = sqrt((A*A)+(B*B)+(C*C))


Mas em Ruby temos
mais do que isso!


eval & cia
(pontuação alta!!!)
deﬁne_method
eval
module_eval
class_eval
instance_eval


blocos/yield


Introspecção
instance_method
method_deﬁned?
private_instance_method
privante_class_method
public_instance_method
etc...


Hooks
Module#included
Module#extended
Class#inherited
method_deﬁned
etc...


Ou seja...


Ou seja...
METAPROGRAMAÇÃO É COMPLEXO E DIFICULTA
A MANUTENÇÃO DO CÓDIGO


Quando veriﬁcar isso
no seu código?


Frequentemente


(já deixei para a fase ﬁnal
de um projeto e o
resultado foi traumático)


Complexidade
Ciclomática


saikuro
http://saikuro.rubyforge.org/


Mede o número de
segmentos linearmente
independentes na
execução do código


Grafo direcionado para
representar os
caminhos de execução


1 def some_method(value)
2 if value % 2 == 0
3 value.times { |i| puts i }
4 else
5 while value >= 0
6 puts value
7 value -= 1
8 end
9 end
10 end


Início

value % 2 == 0

value.times { |i| ... while value >= 0

puts value
puts i

puts value -= 1
Fim


C = A - V + 2P
C => Complexidade ciclomática
A => Número de arestas
V => Número de vértices
P => Número de componentes conectados


Pode ser utilizada para
deﬁnir o número de casos
de teste necessários para
ter total cobertura do
código


Métrica procedural,
mas pode ser usada em
código OO no escopo
de métodos


Duplicação de código


ﬂay
http://ruby.sadi.st/Flay.html


Pesquisa por códigos
SEMELHANTES


Resultados são bons
candidatos para
refactoring


Código que muda com
muita frequência


churn
github.com/danmayer/churn


Código que muda
muito == problemas


Indica quantidade de
alterações ao longo do
tempo


Métodos
Classes
Arquivos


git/mercurial


Code Smells


Sintoma que indica
algum problema mais
sério


O código pode feder
por vários motivos


reek
github.com/kevinrutherford/reek


Aceita opções sobre
quais smells identiﬁcar/
ignorar


Atributos


readers/writers (ou
getters/setters) podem
expor demais seus
objetos


Variáveis de Classe


1 class MyClass
2 @@my_class_variable = 1
3
4 class << self
5 attr_accessor :my_other_class_variable
6 end
7 end


Aumenta o escopo
global


Classe Longa


Muitas linhas


Muitas variáveis de
instância


Muitos métodos


*provavelmente*
fazendo coisa demais!


Método Longo


Lista de Parâmetros
Longa


1 def pay_with_credit_card(number, security_code, holder_name, expiration, value)
2 # ...
3 end


Possíveis soluções


Passar um hash


Encapsular em um
objeto


Baixa Coesão
Feature Envy


1 class Cart
2 def price
3 @item.price + @item.tax
4 end
5 end


Baixa Coesão
Utility Function


Método que não
depende do estado do
objeto


1 class Oven
2 def formatted_temperature(sensor)
3 "#{sensor.temperature} #{sensor.unit}"
4 end
5 end


Polimorﬁsmo Simulado


2 if value > 10
3 if value < 20
4 if value != 15
5 puts "duh"
6 else
7 puts "meh"
8 end
9 end
10 end
11 end


switch também :)
(o reek ainda não identiﬁca)


Uncommunicative
Names


Nomes não reﬂetem a
intenção do código


1 class SomeClass
2 def some_method
3 # ...
4 end
5
6 def some_method_2
7 # ...
8 end
9
10 def another_method
11 a = 10
12 aLocalVariable = 25
13 end
14 end


Pode ser conﬁgurado com
uma lista de regexps
default [/^.[0-9]*$/]


Cobertura de Teste


!= “bem testado”


rcov
http://eigenclass.org/hiki.rb?rcov


Pode indicar trechos do
código que foram
negligenciados


Too Simple To Break


Novas funcionalidades
são adicionadas, mas
continua sem testes


Outros smells
e
erros de estilo


roodi
github.com/martinjandrews/roodi


Atribuição de valor
dentro de uma
estrutura condicional


1 # Deveria ser foo == 100
2 if foo = 100
3 # ...
4 end


1 # Falso positivo...
3 if @value = value
4 # ...
5 end
6 end


case sem cláusula
else


2 case value
3 when 1..10
4 puts "Entre 1 e 10"
5 when 11..20
6 puts "Entre 11 e 20"
7 end
8 end


Classes com muitas
linhas de código
(por padrão limita em 300)


Padrão para nome de
classes e módulos
(veriﬁca se o nome das classes e módulos está em CamelCase)


cláusulas rescue
vazias


1 def calculate_factor(number)
2 begin
3 SOME_CONSTANT / number
4 rescue
5
6 end
7 end


1 def calculate_factor(number)
2 begin
3 SOME_CONSTANT / number
4 rescue => e
5 # Tratar a exceção de alguma forma...
6 end
7 end


Uso de loops com for


1 def print_list(list)
2 for value in list do
3 puts value
4 end
5 end


1 def print_list(list)
2 list.each {|value| puts value }
3 end


Métodos com muitas
linhas de código
(por padrão limita em 20)


Padrão para nomes de
métodos
(veriﬁca se os nomes dos métodos estão snake_case)


rails_best_practices
github.com/ﬂyerhzm/rails_best_practices


Ok...


Mas é muita coisa para
gerenciar!


metric_fu
http://metric-fu.rubyforge.org/


saikuro + ﬂog + ﬂay + rcov
+ reek + roodi + churn +
rails_best_practices


rake metrics:all


Integração Contínua


Métricas ao longo do
tempo


Relatórios!


Problema:


O metric_fu acaba
virando uma dependência
do seu projeto


metrical
github.com/iain/metrical


$ gem install metrical
$ cd /path/of/your/project
$ metrical


Dúvidas?


Obrigado!


Analisando Complexidade de Código Ruby

Recommended

Recommended

More Related Content

Recently uploaded

Recently uploaded (20)

Featured

Featured (20)

Analisando Complexidade de Código Ruby