Alberto Leal

No último sábado realizamos o segundo encontro do Guru Campinas(Grupo de usuários Ruby). O primeiro encontro foi apenas um happy hour, onde tivemos a oportunidade de conhecer algumas pessoas da comunidade.

Desta vez, resolvemos marcar um encontro na Unicamp. E, abrimos um evento no Call4Papers para que as pessoas submetessem propostas de palestras. Neste encontro, compareceram 7 integrantes do grupo. Fiquei bastante contente com esse número. Afinal, é difícil competir com um sábadão ensolarado, né?!  O próximo encontro já tem data definida, será no dia 14/05 na Unicamp. Se você tiver interesse em submeter alguma proposta, cadastre no call4Papers: http://call4paperz.com/events/23

Falei sobre um assunto que eu gosto bastante, que é integração contínua e mostrei um exemplo prático de utilização do Hudson para fazer deploy no Webbynode, pegando o código do Github. Abaixo, os slides da minha apresentação:

E ae, te vejo no próximo encontro no dia 14/05 na Unicamp?

Eu bem que gostaria de falar um pouco sobre o #RailsRumble. Mas, após ler alguns posts que alguns amigos escreveram, inclusive um membro do meu time, o João, percebi que isso não seria necessário. Tudo o que eles escreveram retratam examente a forma como eu vi o evento.  Recomendo, fortemente, que vocês visitem todos os links listados abaixo!

João Almeida - http://www.joaoalmeida.com.br/blog/eventos/rails-rumble-2010-2/

Léo Hackin - http://www.leohackin.com.br/2010/10/rails-rumble-uma-licao-de-vida/

Vítor Pellegrino - http://vp.blog.br/my-impressions-about-railsrumble

E, que venha 2011!!!

Pessoal,

nos últimos meses intensifiquei os meus estudos em Ruby e Rails. Como podem perceber, meus últimos posts foram emcima dessas tecnologias. E, ao longo da última semana, resolvi pegar alguns dos meus resumos e dar uns “tapas” na formatação e no conteúdo, tentando transformá-los em uma espécie de apostila para aqueles que estão começando com a linguagem e preferem material em português.

Gostaria de convidar a comunidade para contribuir com o trabalho. O projeto está no Github,  portanto, aqueles que quiserem contribuir, basta acessar o link do projeto no Github. 

Abraços

É bastante comum trabalharmos com números sequênciais. E, para isso, não é necessário criarmos uma estrutura de iteração para incrementar um contador, por exemplo.

A melhor forma de se ter número sequênciais, em ruby, é utilizar os ranges

Criando um range

Exitem duas maneiras de se criar um range: a primeira é utilizando 2(dois) pontos (..) e a segunda utilizando 3(três) pontos (…) . A diferença entre eles é que quando utilizamos “..” estamos incluindo o último número informado, já com “…” estamos excluindo o último número informado.

numeros = 1..10
numeros2 = 1...10

Iterando um range

(1..10).each{|num| puts num}

(1.0..5.0).each{|num| puts num}#error

Embora seja permitido se criar um range de Float, não é permitido iterá-lo, visto que a classe Float não possui um método succ

Convertendo para Array

num_array = numeros.to_a #[1,2,3,4,5,6,7,8,9,10]
num2_array = numeros2.to_a #[1,2,3,4,5,6,7,8,9]

Falei sobre conversão implícita/explícita quando estamos trabalhando com String. Agora, chegou a vez de falar um pouco sobre conversões com classes numéricas.

A mesma confusão que encontramos quando falamos sobre os métodos to_s e to_str, encontramos quando nos deparamos com to_i, to_int, to_f, to_flt. Vamos valer da mesma regra que foi apresentada para a classe String: Conversão explícita é para os métodos curtos e implícita para os métodos longos.

Assim como o método to_str, muitas classes não definem os métodos implícitos to_int e to_flt.

class MeuNumero
  def to_i
    5
  end

  def to_int
    10
  end
end

meu_numero = MeuNumero.new
puts meu_numero.to_i

meu_numero = MeuNumero.new
array_meu_numero = Array.new(meu_numero)

Existe um pouco de confusão quando estamos falando dos métodos: to_s e to_str. Qualquer objeto, no ruby, pode ser convertido para uma representação em string. Quando olhamos as classes no core nos deparamos com um método to_s (Por exemplo, execute Fixnum.methods e você verá o método), mas não vemos o método to_str. Pense que to_str é para conversão implícita e to_s é para conversão explícita.

Vamos ver um exemplo:

class Automovel
  def to_s
    "Carro"
  end

  def to_str
    "Fiat"
  end
end

auto = Automovel.new
puts auto
puts "O automóvel criado foi #{auto}"
puts "O automóvel criado foi " + auto

# Saída COM o método to_str definido
# Alberto:Desktop Alberto$ ruby post.rb
# Carro
# O automóvel criado foi Carro
# O automóvel criado foi Fiat

É possível notar que, quando definimos o método to_str estamos forçando uma conversão. Vamos executar o mesmo código acima, porém sem o método to_str definido:

class Automovel
  def to_s
    "Carro"
  end
end

auto = Automovel.new
puts auto
puts "O automóvel criado foi #{auto}"
puts "O automóvel criado foi " + auto

# Saída SEM o método to_str definido
# Alberto:Desktop Alberto$ ruby post.rb
# Carro
# O automóvel criado foi Carro
# post.rb:10:in `+': can't convert Automovel into String (TypeError) from post.rb:10

Vale ressaltar que, quando usamos o método puts, esse sempre chama o método to_s do objeto quando desejamos a representação textual de um objeto.

Vamos ver mais um exemplo: Quando tentamos concatenar uma String com um objeto do tipo Fixnum, diretamente, não conseguimos porque a classe Fixnum não possui o método to_str, para conversão implícita.

s = "Número: " + 007
TypeError: can't convert Fixnum into String
    from (irb):3:in `+'
    from (irb):3
    from :0

Agora, quando adicionamos o método em tempo de execução a classe Fixnum (via duck typing), conseguimos executar o código que antes acusava TypeError :

class Fixnum
  def to_str
    self.to_s
  end
end

s = "Número: "+ 007

Outra forma de executar o código, sem ter que adicionar o novo método a classe Fixnum, seria chamar o método to_s diretamente:

s = "Número: "+ 007.to_s