Usando o Plug-in Ruby Development Tools para o Eclipse

Este artigo introduz o uso do plug-in Ruby Development Tools (RDT) para o Eclipse, que permite que o Eclipse torne-se um ambiente de desenvolvimento Ruby de primeira classe. Os desenvolvedores de Ruby que querem aprender como usar a infraestrutura rica da comunidade Eclipse para suportar sua linguagem se beneficiarão, assim como desenvolvedores de Java™ que estão interessados em usar Ruby.

Neal Ford, Application Architect, ThoughtWorks

Neal FordNeal Ford é um arquiteto de aplicativo na ThoughtWorks, uma empresa de serviços profissionais em TI. Neal projeta e desenvolve aplicativos, materiais de instrução, artigos de revista, courseware, apresentações em vídeo/DVD e escreveu os livros Developing with Delphi: Object-Oriented Techniques, JBuilder 3 Unleashed e Art of Java Web Development. Seu principal foco de consultoria é a construção de aplicativos corporativos de grande escala. Ele também fez palestras em conferências de desenvolvedores.



24/Jul/2008 (Primeira publicação 11/Out/2005)

Nota do Editor: Para saber o que há de novo e alterado no RDT desde quando este artigo foi escrito, leia o artigo do developerWorks " Easy Ruby development, the Eclipse way."

Por que Ruby?

Por que qualquer desenvolvedor de Java respeitável deveria se importar com Ruby? Ruby é uma linguagem de script de finalidade geral criada 10 anos atrás no Japão. Contrário à crença popular, é uma linguagem orientada a objetos pura. Diferentemente da tecnologia Java, Ruby não possui escalares, portanto, tudo, incluindo os números inteiros, são objetos de primeira classe. A sintaxe de Ruby pega muito emprestado de Smalltalk, Python e Ada. Como a linguagem de programação Java, Ruby é uma linguagem de herança única, mas oferece alguns recursos avançados que a tecnologia Java não oferece, como encerramentos (pense em classes internas anônimas em esteróides) e combinações (semelhantes a interfaces, mas menos ligadas de forma rígida à classe). Ruby também é altamente portátil, executando em todos os principais sistemas operacionais.

Ruby também está em evidência no momento. As pessoas estão começando a usá-la para os tipos de aplicativos onde se destaca. Como é interpretada e usa determinação de tipo dinâmica, é possível fazer todo ripo de truques de mágica no tempo de execução que são muito difíceis em Java. Um dos recursos surpreendentes possível devido à determinação de tipo dinâmica e a sintaxe expressiva é a capacidade de criar linguagens específicas do domínio em Ruby que permitem trabalhar em um nível mais alto de abstração, distante da sintaxe "bruta" da linguagem. Ruby on Rails é uma estrutura para criar aplicativos da Web suportados por bancos de dados que mostra essa elegância. Rake, a versão de Make e Ant colocadas em um de Ruby, é outro exemplo desse uso potente da linguagem.

A outra razão para começar a brincar com Ruby é que todos os caras legais estão fazendo isso. Muitas das pessoas que reconheceram que a tecnologia Java ia ser importante lá atrás, em 1996 (como Glenn Vanderburg, Bruce Tate e Martin Fowler) estão muito envolvidos com Ruby agora. Mesmo se você não for alterar todos os seus esforços de desenvolvimento para Ruby, talvez tenha chegado a hora de você dar uma olhada nessa linguagem.

Um dos principais fatores limitadores para difundir o desenvolvimento em Ruby é um bom ambiente de desenvolvimento (para aqueles que não querem aprender Emacs). O RDT muda isso. Há maneira melhor de experimentar Ruby do que em seu IDE favorito, o Eclipse?


Configurar

Antes de poder começar a brincar com Ruby, é necessário instalar — ou verificar se você possui — o interpretador e as bibliotecas Ruby e o Ruby Development Environment.

Obtendo Ruby

Ruby está disponível para todas as principais plataformas — e algumas secundárias também. Na verdade, sua distribuição do Linux®, Mac OS X ou Cygwin pode ser que já a possua. Vá para um prompt de comandos e digite ruby -v

Se você obter um número da versão, está pronto para iniciar. Caso contrário, é necessário instalar Ruby. Verifique as distribuições para sua plataforma de opção. A instalação é simples. Por exemplo, para instalar Ruby em uma distribuição do Linux baseada em Debian, como Ubuntu, insira o seguinte em uma linha de comando: sudo apt-get install ruby rdoc irb libyaml-ruby libzlib-ruby ri libopenssl-ruby

Se você estiver executando o Windows®, as opções são fáceis, também. RubyForge, o equivalente de SourceForge específico de Ruby, tem um projeto chamado o One-Click Ruby Installer, um programa que configura o ambiente Ruby no Windows (consulte Recursos). Também inclui diversas ferramentas extras, incluindo um IDE chamado FreeRide, mas você pode ignorar a maioria delas na configuração se estiver usando o RDT.

Os usuários do Mac OS X têm maior facilidade, pois a Apple Computer inclui Ruby nas verões recentes do Mac OS X.


Obtendo Documentos

A documentação e outros materiais de referência são cruciais quando você começa a brincar com uma nova linguagem. É possível obter referências on-line para a documentação da Ruby no principal Web site da Ruby, mas verificará que a documentação lá está um pouco desatualizada (é para a Ruby V1.6 e a versão atual é a 1.8.2). O problema é que os documentos atualizados não foram traduzidos do japonês ainda. No entanto, é possível encontrar boa documentação atualizada em Ruby-doc.org. Inclui a documentação no nível da API (equivalente a Javadoc), juntamente com alguns tutoriais e manuais. (Consulte Recursos.)

Se estiver levando o desenvolvimento em Ruby a sério, você deveria correr o mais rápido possível para obter Programming Ruby: The Pragmatic Programmer's Guide de Dave Thomas e Andy Hunt (consulte Recursos). Essa é a introdução padrão ouro para Ruby e um requisito para uma biblioteca Ruby. Quando for adquirir esse livro, pode pegar Agile Development with Ruby on Rails, também de Dave Thomas, que é uma introdução para Ruby on Rails.

Obtendo o RDT

Agora que você tem uma versão funcional documentada de Ruby em seu computador, você precisa do (consulte Recursos). Esse é um plug-in para o Eclipse que oferece muitos dos recursos com os quais você está acostumado ao editar o código. RDT é um plug-in padrão do Eclipse, com recursos e plug-ins, para que você possa expandir o arquivo zip diretamente na pasta do Eclipse. Os caminhos no archive cuidam do resto.

Nota do Editor: O nome do plug-in Ruby Development Tools (RDT) e onde localizá-lo mudaram desde quando este artigo foi escrito em 2005, mas a função básica e os termos de licenciamento permanecem essencialmente inalterados. O RDT, agora chamado de Aptana RadRails V1.0.3, está disponível no Web site do Aptana. Para fazer download de uma nova versão ou atualizar seu plug-in do Eclipse, siga as instruções de RadRails do Aptana, que serão familiares para usuários do Eclipse. Observe que se você não tiver instalado um plug-in Aptana em sua área de trabalho Eclipse antes, deve seguir as instruções do Aptana para Conectando o Aptana em uma Configuração Existente do Eclipse .

Agora, você está pronto para criar um projeto Ruby (consulte a Figura 1).

Figura 1. Criando um Novo Projeto Ruby
Criando um Novo Projeto Ruby

Ruby possui muito menos requisitos para nomes e estruturas de diretórios do que a tecnologia Java. Criar um projeto em Ruby na verdade cria apenas um diretório e um arquivo .project (não há necessidade do arquivo .classpath , pois Ruby não possui caminho de classe). Outra diferença que pode ser notada em relação à tecnologia Java é que o assistente de projeto Ruby não cria diretórios explícitos src e bin . Ruby é interpretada, portanto, não há nenhum pasta de saída. Se você tiver um pequeno projeto, pode colocar os arquivos de origem Ruby na mesma pasta que o arquivo de projeto. Como alternativa, é possível criar sua própria hierarquia de diretórios. Você verá que Ruby se importa muito menos com isso do que a linguagem de programação Java.

Em seguida, você irá querer um arquivo de origem Ruby. Não há nenhum assistente específico para criar um arquivo de origem Ruby. Há muito menos estrutura necessária para um arquivo de origem Ruby do que na tecnologia Java, portanto, para criar um arquivo Ruby, use o menu que aparece ao clicar no projeto com o botão direito do mouse para criar um novo arquivo.

Figura 2. Criando um Arquivo de Origem Ruby
Criando um Arquivo de Origem Ruby

Não se esqueça de incluir a extensão padrão .rb no arquivo, que é a extensão normal da Ruby. Criar um arquivo Ruby deve abrir a perspectiva Ruby.

Figura 3. Criar um Arquivo de Origem Ruby Ativa a Perspectiva Ruby
Criar um Arquivo de Origem Ruby Ativa a Perspectiva Ruby

A perspectiva Ruby também apresenta uma visualização em estrutura de tópicos, semelhante à oferecida pela perspectiva Java. Como a contraparte Java, permite navegar pelos elementos do arquivo de origem Ruby. Na Figura 4, o método raise_salary_by é realçado na visualização em estrutura de tópicos e de origem.

Figura 4. A Visualização em Estrutura de Tópicos Permite Navegação no Arquivo de Origem
A Visualização em Estrutura de Tópicos Permite Navegação no Arquivo de Origem

Exatamente como outros plug-ins sofisticados, o RDT também inclui recursos de customização no diálogo Janela > Preferências . Esse diálogo de preferências aparece na Figura 5.

Figura 5. RDT Instala Preferências para Customização
RDT Instala Preferências para Customização

O item de menu de preferências permite alterar o realce da sintaxe, a formatação (o deslocamento padrão no mundo Ruby é dois espaços, não quatro, então prepare-se para algum ajuste) e realce da sintaxe. Também permite que você customize os modelos do editor e escolha seu interpretador.


O Editor do RDT

No mundo da tecnologia Java, ficamos acostumados a recursos avançados do editor, o que dificulta ir para outros ambientes que não oferecem o mesmo suporte. Um dos recursos que está ausente no IDE Ruby é o Assistente de Conteúdo, oferecendo consultas sensíveis ao contexto para identificadores. O editor do RDT possui Assistente de Conteúdo para o código Ruby.

Figura 6. O Editor do RDT Fornece o Assistente de Conteúdo
O Editor do RDT Fornece o Assistente de Conteúdo

O Assistente de Conteúdo no editor do RDT é menos específico do que no mundo Java, pois Ruby tem o tipo definido dinamicamente. Você não pode designar um tipo a um retorno de variável ou método em Ruby. O contexto do identificador determina o tipo no tempo de execução. Ruby usa o que é, afetuosamente, chamado de "determinação de tipo pato" — se aceita uma mensagem "quack", deve ser um pato. Apesar de isso poder parecer um problema para aqueles acostumados a linguagens com determinação de tipo de forma forte, esse acoplamento de tipo solto possibilita alguns dos recursos mais potentes da linguagem Ruby. Por exemplo, você pode escrever um manipulador de exceções em Ruby que seja acionado se você chamar um método que não exista e o manipulador de exceções puder sintetizar o método rapidamente e virar para chamá-lo. Esse nível de meta-programação é difícil em linguagens com determinação de tipo de forma forte.

Um dos recursos de compensação para o Assistente de Conteúdo é as convenções de nomenclatura especiais que Ruby usa para identificadores. Por exemplo, em Ruby, todas as variáveis de membro surgem no primeiro uso e são todas identificadas por um símbolo @ como o primeiro caractere do nome. Se você estiver procurando variáveis de membro usando o Assistente de Conteúdo, pode começar digitando @ e ver apenas variáveis de membro.

Figura 7. Convenções de Nomenclatura no Assistente de Conteúdo da Ajuda de Ruby
Convenções de Nomenclatura no Assistente de Conteúdo da Ajuda de Ruby

A determinação de tipo dinâmica ainda afeta a sensibilidade de contexto em Ruby. Na Figura 7, as únicas variáveis de membro legítimas são as que aparecem logo acima da declaração de método, especificamente @name, @salary e @hire_year. As outras variáveis de membro que o Assistente de Conteúdo está captando são de outra classe, definida posteriormente. O editor do RDT não é sofisticado o suficiente ainda para remover por filtro todas as entradas corretas sintaticamente, mas incorretas semanticamente.


Executando e Depurando

Um dos recursos chave de um IDE é a capacidade de executar e depurar os aplicativos construídos a partir do mesmo ambiente. O RDT ativa ambos os recursos.

Especificando um Interpretador

Ruby é uma linguagem interpretada, de forma que você deve associar um interpretador a seu ambiente antes de o RDT poder executar ou depurar seu aplicativo. Essa associação reside no diálogo Windows > Preferências sob o título Ruby e a entrada Interpretadores Instalados .

Figura 8. Associando um Interpretador Ruby ao Ambiente
Associando um Interpretador Ruby ao Ambiente

você aponta o campo de texto "Local" para o diretório bin para a versão de Ruby que você está usando. O RDT capta o restante das informações necessárias. Quando tiver associado o interpretador, você está pronto para executar seu aplicativo.

Executando Aplicativos Ruby

Executar um aplicativo Ruby é praticamente idêntico a executar um aplicativo Java. Você cria uma configuração de execução usando o menu Executar.

Figura 9. Configurando uma Configuração de Execução no RDT
Configurando uma Configuração de Execução no RDT

Ao executar o aplicativo, o RDT efetua shell para o interpretador Ruby e executa o aplicativo na janela do console na parte inferior da área de trabalho Eclipse.

Figura 10. Executando um Aplicativo Ruby no RDT
Executando um Aplicativo Ruby no RDT

Este exemplo mostra a execução de um aplicativo de console, mas a execução de outros tipos de aplicativos (como aplicativos gráficos) funciona da mesma forma.

Depurando com o RDT

Um dos recursos mais críticos necessários de um IDE é a capacidade de depurar seus aplicativos de forma efetiva. O interpretador Ruby inclui um depurador de linha de comando, mas quem quer usar um depurador de linha de comando nesta época de ferramentas gráficas? Felizmente, o interpretador Ruby também transmite informações de depuração através de uma porta específica (configurável) e ferramentas como o RDT podem atender através dessa porta e fornecer os tipos de suporte de depuração esperados pelos desenvolvedores.

Para depurar um aplicativo Ruby no RDT, crie uma configuração de Depuração exatamente como a configuração de Execução criada acima. Você, então, configura um ponto de interrupção clicando na canaleta na margem esquerda e ativa o aplicativo usando o depurador. Exatamente como com a tecnologia Java, o IDE perguntará se você deseja alternar para a perspectiva Depurar. Quando você faz isso, verá algo semelhante a isto:

Figura 11. Depurando um Aplicativo Ruby no RDT
Depurando um Aplicativo Ruby no RDT

O mesmo nível de suporte a depuração encontrado na tecnologia Java aparece no RDT. A área de janela superior esquerda mostra o encadeamento atual em execução. A área de janela superior direita mostra os valores das variáveis. Exatamente como na linguagem de programação Java, é possível se aprofundar em objetos para ver seus valores de variáveis de membro subjacentes. A área de janela esquerda intermediária mostra o código de origem do aplicativo em execução e a área de janela direita intermediária mostra a visualização em estrutura de tópicos — que funciona aqui como no editor, permitindo que você navegue clicando em um identificador). A parte inferior da janela Depurar mostra que o interpretador Ruby transmite informações de depuração na porta 1098 e o RDT atende nessa porta para informações de depuração.

Suporte a depuração é um recurso-chave do RDT. Mesmo se você tiver um editor que tenha excelente suporte a Ruby, você ainda deve depender no depurador da linha de comando para depurar seus aplicativos. Ter um depurador integralmente funcional é um enorme ganho de produtividade.


Testes

Uma das características mais difíceis de Ruby para desenvolvedores Java aceitarem é a determinação de tipo dinâmica. Se você está acostumado a uma linguagem com determinação de tipo de forma forte, a determinação de tipo dinâmica parece um passo em direção à anarquia. A determinação de tipo dinâmica permite todos os tipos de truques avançados de meta-programação que são difíceis ou impossíveis em uma linguagem com determinação de tipo de forma forte. É claro, você também abre mão da rede de segurança da verificação de tipo no tempo de compilação. Há uma maneira de obter o melhor de ambos os mundos?

Os testes de unidade devem ser obrigatórios para linguagens, mas são especificamente críticos em linguagens dinâmicas. Os testes de unidade revelam muito mais do que mera compilação. Na verdade, você deve alterar sua perspectiva do relacionamento entre testes de unidade e compilação. Recentemente, em um painel de especialista em um Simpósio No Fluff, Just Stuff Software, Stuart Halloway (da Relevance, LLC), um profundo pensador sobre desenvolvimento de software, afirmou: "Em cinco anos, vamos ver compilação como uma forma muito fraca de teste de unidade." Os testes de unidade fornecem verificação de que o código faz o que é esperado, não apenas verificação ortográfica de sua digitação.

Considerando a importância dos testes de unidade no mundo Ruby, você esperaria que o RDT facilitasse a execução dos testes de unidade. Ele facilita. Os testes de unidade estão incluídos em Ruby, portanto, não é necessário fazer download de nenhuma extensão adicional. A biblioteca Ruby inclui uma classe TestCase e o conceito de um TestSuite. Você cria seus testes de unidade como qualquer outra classe Ruby, determinando a subclasse de seu teste a partir de Test::Unit::TestCase. A Lista 1 é uma classe de exemplo denominada Employee.

Lista 1. A Classe Employee
class Employee
  def initialize(name, salary, hire_year)
    @name = name
    @salary = salary
    @hire_year = hire_year
  end

  attr_reader :name, :salary, :hire_year
  def raise_salary_by(perc)
    @salary += (@salary * (perc * 0.01))
  end

  def to_s
    "Name is #{@name}, salary is #{@salary}, " +
    "hire year is #{@hire_year}"
  end
 end

O teste de unidade correspondente:

Lista 2. O Teste de Unidade para a Classe Employee
require 'test/unit/testcase' require 'test/unit/autorunner' require 'hr'
class TestEmployee < Test::Unit::TestCase
  @@Test_Salary = 2500
  def setup
    @emp = Employee.new("Homer", @@Test_Salary, 2003)
  end
  def test_raise_salary
    @emp.raise_salary_by(10)
    expected = (@@Test_Salary * 0.10) + @@Test_Salary
    assert( expected == @emp.salary)
  end
end

Para executar esse teste de unidade, crie uma configuração de Execução para a classe de teste de unidade como um tipo Test::Unit .

Figura 12. RDT Inclui uma Configuração de Execução Test::Unit
RDT Inclui uma Configuração de Execução Test::Unit

Ao executar esse teste, você obtém os mesmos elementos de suporte como um teste de unidade Java, incluindo o painel semelhante a JUnit no canto inferior esquerdo.

Figura 13. Exemplo de um Teste de Unidade Executado no IDE
Exemplo de um Teste de Unidade Executado no IDE

Também é possível criar TestSuites em Ruby. TestSuites são classes Ruby que definem um método de conjunto que retorna o TestSuite. O TestSuite consiste nos conjuntos definidos automaticamente em cada um dos TestCases. A Lista 3 é um TestSuite de amostra para duas classes.

Lista 3. TestSuite de Amostra para Duas Classes
require 'test/unit/testsuite'
require 'test/unit/ui/tk/testrunner'
require 'test/unit/ui/console/testrunner'
require 'TestEmployee'
require 'TestManager'


class TestSuite_AllTests
    def self.suite
        suite = Test::Unit::TestSuite.new("HR Tests")
        suite << TestEmployee.suite
        suite << TestManager.suite
        return suite
    end
end

#Test::Unit::UI::Tk::TestRunner.run(TestSuite_AllTests)
Test::Unit::UI::Console::TestRunner.run(TestSuite_AllTests)

Diferentemente do exemplo anterior de executar um único TestCase, o conjunto executa um aplicativo independente. Ruby inclui duas maneiras de mostrar os resultados do TestSuite. A primeira, o Console Test Runner, emite a saída de seus resultados no console. A segunda, o Tk TestRunner, cria um diálogo familiar para mostrar os resultados dos testes. O diálogo Tk TestSuite aparece na Figura 14.

Figura 14. O Diálogo TestSuite Gráfico
O Diálogo TestSuite Gráfico

O que Vem em Seguida?

A versão atual do RDT é 0.50. Seus desenvolvedores estão trabalhando duro na próxima versão: 0.60. As melhorias planejadas para o próximo release incluem:

  • Desdobramento de código— Desdobramento pode ser ativado para classes e métodos.
  • Visualização da estrutura de tópicos— Mais detalhada, com suporte para variáveis locais.
  • Visualização de RI— Use o utilitário ri de Ruby a partir de uma visualização do RDT.
  • Tags de tarefa— Crie tarefas para palavras-chave configuráveis (como TODO, FIXME) em comentários de Ruby.
  • Melhorias do editor— Conclusão automática de colchetes, parênteses e aspas simples/duplas; melhor assistente de código.
  • Atalhos de inspeção— Atalhos configuráveis para inspeções usadas frequentemente durante uma sessão de Depuração, como mostrar todos os métodos de um objeto, constantes globais, etc.

A próxima versão fará melhor uso do compilador de bytecode JRuby. JRuby é um projeto que permite que o código Ruby compile para bytecode Java. Isso significa que a próxima versão do RDT será mais fácil de incorporar no mundo Eclipse, oferecendo suporte ainda melhor.


Resumo

Um dos principais conselhos do livro Pragmatic Programmer: From Journeyman to Master afirma que você deve aprender uma nova linguagem de programação todo ano para manter-se atualizado e permitir que novas linguagens ensinem coisas sobre a que você usa todo dia. Ruby finalmente atingiu o ponto de mudança de ubiquidade, orientada parcialmente pelo sucesso do projeto Ruby on Rails. Chegou a hora de incluir Ruby em seu arsenal de ferramentas. O RDT é uma excelente maneira de experimentar enquanto permanece em solo seguro que você já conhece.

Recursos

Aprender

  • Para saber o que há de novo e alterado no RDT desde quando este artigo foi escrito, leia o artigo do developerWorks " Easy Ruby development, the Eclipse way."
  • Home da linguagem Ruby, Ruby-lang.org, é um portal que leva a outros sites e documentação úteis de Ruby.
  • Ruby on Rails é uma estrutura de aplicativo da Web influente baseada em Ruby. Esse site permite fazer download de rails e ver aplicativos de amostra.
  • Rubyforge.org contém One-Click Ruby Installer, um programa que configura o ambiente Ruby no Windows.
  • Encontre documentação atualizada sobre Ruby em Ruby-doc.org.
  • Programming Ruby, The Pragmatic Programmer's Guide, 2nd Edition, de Dave Thomas, é o guia seminal para a linguagem Ruby. Escrito em um estilo muito legível, esse livro é o primeiro livro que as pessoas novatas para Ruby devem incluir em suas estantes de livros. Um dos excelentes clássicos de literatura de engenharia de software, leia esse livro mesmo se você não ligar para Ruby.
  • Agile Development with Rails: A Pragmatic Guide, de Dave Thomas e David Heinemeier Hansson, é o livro de consulta se você estiver interessado em Rails. Esse livro é o guia definitivo para desenvolvimento com Rails.
  • The Pragmatic Programmer: From Journeyman to Master, de Andrew Hunt e David Thomas, sugere que desenvolvedores devem aprender uma nova linguagem por ano.
  • Glenn Vanderburg é um intelectual de software que oferece insights e perspectivas interessantes. Ele foi um dos primeiros a entender e divulgar o verdadeiro potencial da tecnologia Java — escrevendo os primeiros livros avançados sobre Java — e tem sido um forte partidário de Ruby há anos.
  • Bruce Tate, famoso por Bitter Java e Bitter EJB , também adotou Ruby e as possibilidades de executar a transição da tecnologia Java para Ruby. Ele tem diversos livros sobre trabalhos que mostram como você pode se transformar de uma pessoa Java em um Rubyista. Leia sua série " Segredos do Sucesso de Desenvolvimento Leve" no developerWorks.
  • Relevance, LLC é uma empresa de consultoria e treinamento que se especializa em Ruby e Ruby on Rails.
  • Martin Fowler é um dos nomes mais conhecidos em engenharia de software. Ele entende conceitos profundos e escreve sobre eles com clareza surpreendente. Tem sido um defensor sonoro de Ruby e dos tipos de coisas que você pode fazer com Ruby há anos e o resto do mundo está só começando a perceber. Ele escreve sobre Ruby frequentemente em seu incrível blog.
  • developerWorks oferece artigos e tutoriais sobre Ruby em miríade, incluindo " Depurando Programas Ruby 101" e " Automatizando Tarefas com Rake."
  • Visite Zona de Software Livre do developerWorks para obter informações extensivas sobre como executar ações, sobre ferramentas e atualizações de projetos para ajudá-lo a se desenvolver com tecnologias de software livre e usá-las com produtos IBM.

Obter produtos e tecnologias

  • Obtenha o Ruby Development Tools, o plug-in para Eclipse que inclui suporte para Ruby, incluindo suporte para o Assistente de Conteúdo, depuração e teste de unidade.
  • Rake, disponível em Rubyforge.org, é a ferramenta de construção de Ruby. Rake oferece uma linguagem para executar construções, oferecendo o melhor de Make e Ant. Também demonstra como a sintaxe flexível de Ruby facilita a criação de linguagens altamente específicas específicas do domínio.
  • Inove seu próximo projeto de desenvolvimento de software livre com software de avaliação da IBM, disponível para download ou em DVD.
  • Localize o plug-in Aptana RadRails Eclipse no Web site do Aptana. Para fazer download de uma nova versão ou atualizar seu plug-in do Eclipse, siga as instruções de RadRails do Aptana.

Comentários

developerWorks: Conecte-se

Los campos obligatorios están marcados con un asterisco (*).


Precisa de um ID IBM?
Esqueceu seu ID IBM?


Esqueceu sua senha?
Alterar sua senha

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


A primeira vez que você entrar no developerWorks, um perfil é criado para você. Informações no seu perfil (seu nome, país / região, e nome da empresa) é apresentado ao público e vai acompanhar qualquer conteúdo que você postar, a menos que você opte por esconder o nome da empresa. Você pode atualizar sua conta IBM a qualquer momento.

Todas as informações enviadas são seguras.

Elija su nombre para mostrar



Ao se conectar ao developerWorks pela primeira vez, é criado um perfil para você e é necessário selecionar um nome de exibição. O nome de exibição acompanhará o conteúdo que você postar no developerWorks.

Escolha um nome de exibição de 3 - 31 caracteres. Seu nome de exibição deve ser exclusivo na comunidade do developerWorks e não deve ser o seu endereço de email por motivo de privacidade.

Los campos obligatorios están marcados con un asterisco (*).

(Escolha um nome de exibição de 3 - 31 caracteres.)

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


Todas as informações enviadas são seguras.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Software livre
ArticleID=382647
ArticleTitle=Usando o Plug-in Ruby Development Tools para o Eclipse
publish-date=07242008