O que é Ruby? (Wikipedia)

Ruby é uma Linguagem de programação interpretada, com Tipagem Dinâmica e Tipagem Forte, orientada a objetos e, com várias semelhanças com Perl, Python e SmallTalk.
Projetada tanto para a programação em grande escala quanto para
codificação rápida, tem um suporte a orientação a objetos simples e
prático. A linguagem foi criada pelo japonês Yukihiro Matsumoto, que aproveitou as melhores idéias das outras linguagens da época.
Esta linguagem possui vastos repositórios de bibliotecas
disponíveis em sites como Ruby Forge e Ruby Application Archive (RAA).
Existe, ainda, uma ferramenta bastante útil para instalação de
bibliotecas, chamada Ruby Gems. O projeto mais famoso desenvolvido em Ruby é o meta-framework Rails (Veja: Ruby on Rails).
História


Ruby se tornou reconhecida no meio especializado desde que Dave Thomas e Andrew Hunt, conhecidos como "Programadores Pragmáticos", adotou-a como uma de suas linguagens preferidas e acabou por escrever um dos mais completos livros sobre a linguagem, o Programming Ruby.
Com o advento desta publicação, a linguagem passou a contar com uma boa
fonte de iniciação e referência em inglês, aumentando consequentemente
o número de adeptos da linguagem no Ocidente.
Ultimamente, devido a grande exposição de um framework web feito em Ruby, o Rails desenvolvido por David Heinemeier Hansson, a linguagem tem sido foco da mídia especializada justamente pela sua praticidade.
Esta mesma praticidade inclusive é um dos conceitos básicos da linguagem. É possível fazer algoritmos que resolvam seus problemas, não necessitando se preocupar com as limitações da linguagem ou do interpretador.

Como surgiu o nome "Ruby"


O nome "Ruby", foi decidido durante uma sessão de bate-papo online
entre Matsumoto (Matz) e Keiju Ishitsuka em 24 de fevereiro de 1993,
antes que qualquer linha de código tinha sido escrita para a linguagem.
Inicialmente foram propostos dois nomes: "Coral" e "Ruby", sendo esse
último nome proposto escolhido mais tarde por Matz em um e-mail para
Ishitsuka.

Características


Para manter a praticidade, a linguagem possui algumas características interessantes:

• A sintaxe é enxuta, quase não havendo necessidade de colchetes e outros caracteres.
  
• Todas as variáveis são objetos, onde até os "tipos primitivos" (tais como inteiro, real, entre outros) são classes.
  
• Estão disponíveis diversos métodos de geração de código em tempo real, como os "attribute accessors".
  
• Através do Ruby Gems, é possível instalar e atualizar bibliotecas com uma linha de comando, de maneira similar ao APT do Debian Linux.
  
• Code blocks (blocos de código), ajudam o programador a
  passar um trecho de instruções para um método. A idéia é semelhante aos
  "callbacks" do Java, mas de uma forma extremamente simples e bem
  implementada.
  
• Mixins, uma forma de emular a herança múltipla, sem cair nos seus problemas.
  
• Tipagem dinâmica, mas forte. Isso significa que todas as variáveis
  devem ter um tipo (fazer parte de uma classe), mas a classe pode ser
  alterada dinamicamente. Os "atalhos" citados acima, por exemplo, se
  beneficiam da tipagem dinâmica para criar os métodos de
  acesso/alteração das propriedades.
  

Ruby está disponível para diversas plataformas, como Microsoft Windows, .NET, Linux, Solaris e Mac OS X, além de também ser executável em cima da máquina virtual do Java (através do JRuby).

Orientada a objetos


Muitos programadores consideram o Ruby uma linguagem de programação totalmente orientada a objetos (de maneira similar ao SmallTalk), porém devido a inexistência de conceitos padrões para especificação de linguagens OO, isto não pode ser provado.
Ruby não possui tipos primitivos, mas sim todos tipos são classes,
assim como todas variáveis são objetos. Como exemplo, conjunto de
caracteres é uma instância da classe String, inteiro é da Fixnum e matriz é Array.
Um conceito interessante também é que a maioria dos operadores
binários e unários são, na realidade, métodos. Ou seja, podem ser
alterados da mesma forma que os operadores em C++. Exemplo:

Código:

class MeuNumero < Fixnum
  def +(numero)
    42
  end
end
 
numero = MeuNumero.new(1)
# Repare como um operador de soma é um método em ruby, ao contrário de outras linguagens
puts numero + 2 # 1+2 = 42 ??? Sim, sobrescrevemos o método de soma para retornar 42 sempre.

Attribute Readers e Writers


Uma das funcionalidades mais úteis do Ruby são os attribute accessors, que geram getters e setters em tempo de execução. Compare os seguintes códigos:

Código:

class Pessoa
  # Não utilizando Attribute Accessor
  def nome
    @nome
  end
 
  def nome=(valor)
    @nome = valor
  end
 
  def nascimento
    @nascimento
  end
 
  def nascimento=(valor)
    @nascimento = valor
  end
 
  def cpf
    @cpf
  end
 
  def cpf=(valor)
    @cpf = valor
  end
end
 
# Utilizando Attribute Accessor
class Pessoa
  attr_accessor :nome, :nascimento, :cpf
end

Controle de acesso


Em Ruby, você pode deixar três tipos de acesso aos métodos:
métodos públicos, privados e protegidos. Os métodos públicos podem ser
acessados por qualquer classe e por qualquer objeto (instância). Os
métodos privados podem ser acessados somente por objetos de mesmo tipo
(mesma classe).
Métodos protegidos são métodos que podem ser acessados por qualquer
objeto dentro da mesma estrutura hierárquica da classe. Por exemplo,
uma classe

Código:

Pessoa < SerHumano

pode acessar métodos protegidos de SerHumano. Mas, ao contrário da
maioria das linguagens orientadas a objeto, você especifica o controle
de acesso por "bloco", como nos exemplos abaixo:

Código:

class Pessoa
  attr :nome, :nascimento, :cpf
 
  def metodoPublico
  end
 
  protected
 
  def metodoProtegido
  end
 
  def outroMetodoProtegido
  end
 
  private
 
  def metodoPrivado
  end
 
  def outroMetodoPrivado
  end
 
  public
 
  def deNovoMetodoPublico
  end
 
end

Você pode ainda declarar todos seus métodos sem definir a visibilidade do método em bloco, mas usando outra sintaxe:

Código:

class Pessoa
 
  attr :nome, :nascimento, :cpf
 
  def metodoPublico
  end
 
  def metodoProtegido
  end
 
  def outroMetodoProtegido
  end
 
  def metodoPrivado
  end
 
  def outroMetodoPrivado
  end
 
  def deNovoMetodoPublico
  end
 
  public :metodoPublico, :deNovoMetodoPublico
  protected :metodoProtegido, :outroMetodoProtegido
 
  private :metodoPrivado, :outroMetodoPrivado
 
end

Modules, os helpers e classes agrupadas


Além das classes normais, temos também os "Modules", que são
parecidas com classes, mas servem para agrupar os métodos que
geralmente colocamos nas classes "Helper" em outras linguagens. Dessa
forma, podemos fazer um módulo Debug que tem diversos métodos úteis
para a depuração de nossos programas. Por exemplo, podemos adicionar um
método que nos retorna informações sobre um objeto (instância):

Código:

module Debug
  LEVEL = "producao"
  def info
    "#{self.class} (\##{self.object_id}): #{self.to_s}"
  end
end

Este código foi baseado no exemplo de Modules do livro "Pickaxe"
(Programming Ruby: The Pragmatic Programmer's Guide). Em Java, podemos
fazer algo semelhante, utilizando frameworks para orientação a
aspectos, que são, em geral, mais complexos: ou alteram o fonte logo
antes da compilação, ou alteram o byte-code de classes já compiladas.
Em ambos os casos, o código é "injetado" em cada classe, diferente do
paradigma do Ruby, que "herda" o comportamento, deixando o código em apenas um lugar.

Mixin's, resposta simples ao problema da herança múltipla


Em Orientação a Objetos, a herança múltipla é geralmente considerada
um grande problema, pois pode acabar trazendo mais danos do que
vantagens. Ruby, assim como a maioria das linguagens OO, não
suporta herança múltipla diretamente. Ao invés disto, você pode
adicionar comportamentos a uma classe, utilizando os Mixin’s. Eles
funcionam como os includes: você só declara qual a classe que deseja
herdar o comportamento. Deste jeito:

Código:

class MeuObjeto < ObjetoPai
  include Debug
  include Comparable
end

Nesta classe, estamos herdando diretamente de ObjetoPai, mas
"incluindo" o comportamento das classes "Debug" e "Comparable",
deixando isso totalmente transparente à classe usuária, mantendo o
encapsulamento.

Code Blocks


"Code blocks", ou blocos de código, são trechos de código que são
passados como parâmetros para métodos. "Code blocks" são extremamente
usados em Ruby, sendo um dos responsáveis pela manutenção da
simplicidade nos códigos. Blocos são limitados por chavetas ou por "do
end". Em geral, usa-se chavetas quando o bloco possui apenas uma linha,
e "do end" quando temos mais de uma. Por exemplo:

Código:

IO.readlines("hosts.txt").each do | linha |
  puts linha.chomp
end

# Esta linha faz o mesmo:
IO.readlines("hosts.txt").each { | linha | puts linha.chomp }

Neste caso, estamos usando o método "each" da classe "Array", que
obtemos através do método "readlines" da classe "IO". O método
"readlines" é responsável por abrir o arquivo, ler as linhas, executar
o código que foi recebido no bloco, passando "linha" como parâmetro e
fecha o arquivo.
Exemplo de como implementar um método que aceita um "code block":

Código:

class Paises
  @paises = ["Argentina", "Brasil", "Paraguai", "Uruguai"]
 
  def self.each
    for i in 0..@paises.length
      @paises[i]
    end
  end
 
  def self._each
    @paises.each { |p| puts p }
  end
 
end
 
#chamada da versão original do método estático "each" da classe "Paises"
Paises.each do | pais |
  puts pais
end
 
#resultado
Argentina
Brasil
Paraguai
Uruguai
 
#chamada da 2ª versão do método estático "each"
Paises._each
 
#resultado
Argentina
Brasil
Paraguai
Uruguai

Neste exemplo, o código de iteração foi implementado dentro da
classe "Paises", no método "each", que será chamado pelo usuário da
classe. Assim, não faz-se necessário saber como obter os dados nem como
efetuar a iteração. Observe as duas maneiras de implementação e chamada
do método.

Tratamento de exceções


Como a maioria das linguagens modernas, Ruby também possui suporte para tratamento de exceção. As palavras-chave para isto são "begin", "rescue" e "ensure".
"Begin" inicia um trecho que pode cair em alguma exceção. "Rescue"
determina o comportamento em caso de uma exceção específica ou não.
"Ensure" é o código que será executado independente de ter havido
exceção ou não.
Ao contrário de outras linguagens, Ruby não exige que um
trecho passível de exceção esteja obrigatoriamente dentro de um bloco
"begin". O programador é livre para determinar se quer ter o controle
sobre as exceções ou não.
Além destas palavras-chave, temos também o "retry", que re-executa o
trecho a partir do "begin". Isso é extremamente útil, já que nos dá a
possibilidade de arrumar o erro, ou tentar outros parâmetros. Como
exemplo, pegamos este trecho de código da biblioteca "net/smtp",
escrito por Minero Aoki e citado no livro Pickaxe (Programming Ruby: The Pragmatic Programmer's Guide).

Código:

@esmtp = true
begin
  # First try an extended login. If it fails because the
  # server doesn't support it, fall back to a normal login
  if @esmtp then
    @command.ehlo(helodom)
  else
    @command.helo(helodom)
  end
rescue ProtocolError
  if @esmtp then
    @esmtp = false
    retry
  else
    raise
  end
end

Quem está por trás do Ruby?


Ainda hoje, Matz é o responsável por todas as decisões não-consensuais do Ruby.
Ou seja, qualquer divergência quanto à implementação de uma nova
funcionalidade é resolvida pelo "ditador benevolente". Apesar desta
"dependência", a comunidade é forte a ponto de sobreviver "caso o Matz
seja atropelado por um autocarro espacial". Existem pessoas que estão
tão inteiradas com o código quanto o próprio Matz. Diferentemente de
outras tecnologias opensource, não existe uma empresa por trás de suas
operações, suportando os custos. O projeto sobrevive de doações feitas
pelos usuários satisfeitos e por empresas que conseguiram aumentar sua
produtividade utilizando Ruby.

Ruby para administradores de sistemas


Depois de mostrar um pouco de como Ruby funciona por dentro, vamos adentrar em um tópico um pouco mais prático. Hoje em dia, a maioria dos administradores de sistemas Unix utilizam Perl
ou Shell Script como ferramenta para resolver os problemas diários.
Isso implica no aprendizado de uma linguagem que nem sempre é amigável,
com regras nem sempre claras. Por vezes, os administradores acabam
demorando muito tempo no desenvolvimento destes scripts. Por este
motivo, cada vez mais administradores de sistemas estão usando Ruby e Python
para resolver seus problemas. Abaixo, um exemplo real que nos foi
apresentado há algum tempo. A idéia era fazer um pequeno script que
verifica se o serviço da porta 80 (web) de alguns servidores estavam
ativos.

Código:

require 'net/http'
 
File.open("hosts.txt", "r").each_line do | host |
 
  conexao = Net::HTTP.new(host.chomp, 80)
  resposta, conteudo = conexao.get("/", nil)
 
  if resposta.code.to_i > 400
    # aqui vai a rotina pra enviar email...
  end
end

Como podemos ver, em 9 linhas fizemos um script que pode ser colocado como "cronjob" em qualquer Unix.

Exemplos de código


Array (vetor)

Código:

a = [1, 'hi', 3.14, 1, 2, [4, 5]]
 
a[2]                      # 3.14
a.reverse                # [[4, 5], 2, 1, 3.14, "hi", 1]
a.flatten.uniq            # [1, "hi", 3.14, 2, 4, 5]

Booleanos

Código:

t = true
f = false
n = nil
t.class      #TrueClass
f.class      #FalseClass
n.class      #NilClass

Constantes


Constantes são variáveis que tem seu nome começado com uma letra maiúscula.

Código:

Pi = 3.1415926
Pi = 10
warning: already initialized constant Pi   #Aviso que Pi é uma constante
puts Pi      #Porém nao impede que o Pi receba outro valor

Hash (dicionário)

Código:

hash = {'water' => 'wet', 'fire' => 'hot'}
puts hash['fire']     
 
hash.each_pair do |key, value|
  puts "#{key} is #{value}"
end
 
  # Prints:            water is wet
  #                    fire is hot
 
hash.delete_if {|key, value| key == 'water'}  # Deletes 'water' => 'wet'

Classes


Uma das grandes vantagens das classes em Ruby é o fato de
elas serem abertas para alteração. Isso não quer dizer estender a
classe e sim alterá-la em tempo de execução. Por exemplo, suponha que
precise de um novo método na classe String de Ruby para capturar sempre
a primeira letra. Em outras linguagens, o comum é criar métodos
utilitários para realizar a operação. Em Ruby, simplesmente altera-se a
classe para que ela possua tal método. Exemplo:

Código:

class String
  def first
    "" << self[0]
  end
end
 
puts "Marcos Pereira".first

Isso mostra o quanto Ruby pode se adaptar às necessidades do programador.

Exemplos de classes

Código:

class Person
  def initialize(name, age)
    @name, @age = name, age
  end
 
  def <=>(person)
    @age <=> person.age
  end
 
  def to_s
    "#{@name} (#{@age})"
  end
 
  attr_reader :name, :age
end
 
group = [ Person.new("John", 20),
          Person.new("Markus", 63),
          Person.new("Ash", 16)
        ]
 
puts group.sort.reverse

Código:

class Pessoa < SerHumano # heranca
 
  include Mamifero # emulando heranca multipla
 
  # cria tanto metodos de leitura como escrita... Em java, seria setNome e getNome
  attr :nome
 
  # isso cria o metodo de leitura de estado. Em java, seria getIdade
  attr_reader :idade
 
  # isso cria o metodo de mudanca de estado. Em java, isso seria o setNascimento
  attr_writer :nascimento
 
  # "self." antes do nome significa que é um metodo de classe
  def self.comer(comida)
  end
 
  # sem "self.", significa que é um método de "instância"
  def timbreDeVoz()
  end
 
  # sim, qualquer caracter eh possivel no nome dos metodos ;-)
  def correr!()
  end
 
  # inclusive, fazer sobrecarga (overload) de operadores
  def =(outrovalor)
  end
 
end

Ligações Externas

• (em inglês) Página oficial
  
• (em inglês) RAA - Ruby Application Archive
  
• (em português) Ruby Brasil - comunidade brasileira
  
• (em português) ruby << portuguese - comunidade portuguesa
  
• (em inglês) Learning Ruby
  
• (em inglês) Ruby Learning Online Course
  
• (em português) Tutorial Ruby
  
• (em inglês) Why's (Poignant) Guide to Ruby