Ruby (linguagem de programação)

Origem: Wikipédia, a enciclopédia livre.

Nota: Se procura outros significados de Ruby, consulte Ruby.

Ruby
Paradigma:	Orientação a objeto
Surgido em:	1995
Última versão:	1.8.6 ()
Criado por:	Yukihiro Matsumoto
Estilo de tipagem:	dinâmica, forte
Compiladores:
Dialetos:
Influenciada por:	Perl, SmallTalk, Python
Influenciou:
Licença:	{{{licença}}}
Website:	{{{website}}}

Ruby é uma linguagem de programação interpretada, com tipagem dinâmica e forte, orientada a objetos com vastas semelhanças com Perl, SmallTalk e Python.

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 software mais famoso desenvolvido em Ruby é o Ruby on Rails.

[editar] História

Ruby se tornou reconhecida no meio especializado desde que Dave Thomas, conhecido como um dos "Programadores Pragmáticos", adotou-o 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 Ruby on 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 desta linguagem. É possível fazer algoritmos que resolvam seus problemas, não necessitando se preocupar com as limitações da linguagem ou do interpretador.

[editar] 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 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).

[editar] 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:

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.

[editar] 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:

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

[editar] 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

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:

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:

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

[editar] 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):

module Debug
  LEVEL = "producao" 
  def info
    "#{self.type.name} (\##{self.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.

[editar] 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:

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.

[editar] 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:

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":

class Paises
 
  @paises = ["Argentina", "Brasil", "Paraguai", "Uruguai"]
 
  def Paises.each
    for i in 0...@paises.length
      yield @paises[i]
    end
  end
end
 
Paises.each do | pais |
  puts pais
end

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 precisa saber como obter os dados nem como efetuar a iteração.

[editar] 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).

@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

[editar] 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 ônibus 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, bancando os custos. O projeto sobrevive de doações feitas pelos usuários satisfeitos e por empresas que conseguiram aumentar sua produtividade utilizando Ruby.

[editar] 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 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.

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.

[editar] Exemplos de código

[editar] Array (vetor)

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]

[editar] Hash (dicionário)

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'

[editar] 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:

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

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

[editar] Exemplos de classes

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

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

[editar] Ligações externas

• (en) Site oficial de Ruby
• (pt) Ruby Brasil
• (pt) Tutoriais traduzidos
• (en) Learning Ruby
• (en) Ruby Learning Online Course
• Tutorial Ruby
• (en) Why's (Poignant) Guide to Ruby
• RAA - Ruby Application Archive