Contribuição de
Dezembro de 2007 [Número da versão: V6.0-2]
Este tutorial oferece um tour super rápido do desenvolvimento da aplicação Ruby and Ruby no NetBeans IDE. O tutorial mostra-lhe como usar o suporte a
Ruby do IDE para realizar algumas das fases típicas
do desenvolvimento da aplicação.
O tutorial é projetado de forma que você não precise seguir uma ordem específica. Talvez você queira passar rapidamente por ele e depois retornar a cada seção quando houver tempo. Se você preferir um tutorial passo a passo,
talvez queira primeiro
experimentar
Criando um weblog Ruby em 10 minutos.
Consulte Instalando e configurando o suporte a Ruby para
obter informações sobre como
instalar ou configurar o suporte a Ruby do NetBeans e
trabalhar com servidores de banco de dados em projetos Ruby on Rails do NetBeans.
Criando um projeto Ruby
Um projeto é o equivalente ao ambiente de trabalho de uma aplicação Web. Quando cria um novo projeto Ruby, você tem a opção de criar
um projeto ou criar um novo conjunto de pastas com
modelos para seu projeto Ruby.
Observação: quando você abre um projeto Ruby ou JRuby
construído fora do IDE, a única modificação relacionada ao software do NetBeans
que o IDE faz no projeto é criar uma pasta
nbproject, que contém os
metadados do NetBeans.
Você pode ter vários projetos abertos no IDE ao mesmo tempo. Quando
tem mais de um projeto aberto, você deve especificar qual
é o projeto principal. O projeto principal é aquele que o
IDE executa quando você clica no botão Executar projeto principal. Para alternar
o projeto principal, clique com o botão direito do m ouse em um projeto na janela
Projetos e escolha Definir como projeto principal.
Quando você cria um novo projeto Ruby, o IDE cria um arquivo
chamado main.rb por padrão, e define esse arquivo como
o script principal. Quando você clica no botão Executar projeto principal
(
),
o IDE salva todas as alterações e executa o script principal. Para alternar para um
script de inicialização diferente, clique com o botão direito do mouse no nó
Projeto na janela Projetos e escolha Propriedades
no menu pop-up. Selecione a categoria Executar e, no campo de texto
Script principal, digite o nome do arquivo.
Observação: o arquivo main.rb é criado
para projetos Ruby. Quando você cria um projeto Ruby on Rails,
como mostrado na seção
Criando um projeto Ruby on Rails, o IDE
não cria um arquivo main.rb.
Experimente
Abaixo estão as etapas para criar um projeto Ruby.
Caso ainda não o tenha feito,
inicie o IDE, usando a etapa apropriada
na lista seguinte:
Windows, Solaris e Linux.
Clique duas vezes no ícone da área de trabalho do NetBeans.
Mac. Clique duas vezes no ícone do NetBeans na pasta de instalação.
Clique com o botão direito do mouse em um lugar vazio na janela Projetos e escolha Novo projeto no menu pop-up.
No assistente para Novo projeto, selecione Ruby no painel Categorias,
selecione Aplicação Ruby
no painel Projetos e clique em Próximo. Se este for o primeiro projeto Ruby que você abriu ou criou, deve aparecer uma caixa de diálogo pedindo para você escolher um intérprete Ruby. Selecione
uma das opções de intérprete e clique em OK.
Chame o projeto, por exemplo de simple_ruby_application,
e clique em Terminar.
O IDE exibe o arquivo main.rb no editor.
Observe como o código chama puts para exibir
a string "Hello World".
A janela Projeto mostra uma visualização lógica dos
arquivos do projeto. Clique na aba Arquivos para visualizar o
layout físico, em seguida, volte para a janela Projetos. Com projetos
Ruby, as visualizações são muito semelhantes.
Clique no botão Executar projeto principal
()
para executar a aplicação.
O IDE exibe a saída em uma janela na parte inferior do
IDE, como mostrado abaixo.
Figura 1: Janela Saída
Trabalhando com arquivos Ruby
Você trabalha com arquivos do projeto Ruby de forma semelhante
a que trabalharia com eles em um editor de texto. Abra um arquivo, clicando duas vezes
no nó do arquivo na janela Projetos
ou na janela Arquivos. Você também pode pressionar
Alt-Shift-O (use Ctrl-Shift-O no Mac)
para acessar os arquivos por nome.
O editor do IDE oferece muitos recursos para facilitar suas tarefas de programação. Você
aprenderá sobre alguns dos recursos básicos de edição
nesta seção. Uma lista abrangente dos
recursos de edição pode ser encontrada na página wiki do NetBeans
Ruby
Editing.
Experimente.
Siga estas etapas para criar um projeto Ruby simples que exibe
uma lista de produtos. Primeiro, crie uma classe para um item de produto individual. Em seguida, crie uma classe para a lista de itens e um arquivo de dados para fornecer os dados do produto. Por último,
edite o arquivo main.rb para exibir a lista. Conforme você desenvolve
o código, as etapas também introduzirão recursos de edição.
Criar a classe de item
Crie um projeto Ruby, ou use aquele que você
criou na seção anterior.
Na janela Projetos, crie um arquivo de classe,
clicando com o botão direito do mouse no nó Arquivos de código-fonte e
escolhendo Novo > Classe Ruby no menu pop-up. Digite
Item na caixa de texto Classe
e clique em Terminar.
O IDE cria um arquivo chamado item.rb e abre o arquivo
no editor.
Substitua o conteúdo do arquivo item.rb pelo
seguinte código incorreto. Você corrigirá o código nas etapas subseqüentes.
Amostra de código 1: classe Item
class Item
def initialize(id, type, price)
end
def simple_method(id, type, price)
@id = id
@type = type
@price = price.to_f
end
def to_s
"Item #{@id} is a #{@type}: Price $#{@price}"
end
end
Clique com o botão direito do mouse no código-fonte e escolha Formatar
no menu pop-up para reformatar o código.
Observe as linhas cinzas sob os argumentos
do método inicializar, como mostrado na
figura seguinte. Essas linhas identificam
as variáveis não utilizadas. Você corrigirá esse erro nas duas
próximas etapas.
Figura 2: Variáveis não utilizadas
Coloque o cursor em @type no simple_method
e pressione
Alt-Shift-Ponto (use Ctrl-Shift-Ponto no Mac)
para selecionar a linha. Pressione a combinação de teclas
mais uma vez para selecionar o bloco, como mostrado
na figura seguinte.
Figura 3: Seleção de várias linhas
Clique com o botão direito do mouse no código-fonte e escolha Recortar no menu pop-up.
Coloque o cursor no início do método
(inicializar
do construtor) e pressione Shift-Enter para adicionar uma nova linha sob
a linha atual. Clique com o botão direito do mouse na nova linha e escolha Colar no menu pop-up.
A finalidade do simple_method era
manter o código necessário para as etapas anteriores. Você
agora pode excluir esse método. Primeiro, coloque o cursor na
instrução end
do
simple_method.
Observe que o IDE realça a
def correspondente.
Pressione Alt-Shift-Ponto
(use Ctrl-Shift-Ponto no Mac)
para selecionar o método, em seguida, pressione Backspace para
excluí-lo.
Coloque
o cursor na linha vazia e pressione Ctrl-E
(Use Cmd-E no Mac) para
removê-la.
Essa etapa junto com as duas próximas mostra como usar auto-completar de código. Abra uma linha na parte superior do bloco da classe,
em seguida, coloque o cursor na linha, digite attr_a,
e pressione Ctrl-Espaço (se Ctrl-Espaço não funcionar em seu
sistema, use Ctrl-\).
O IDE exibe uma lista de possíveis conclusões de código, como
mostrado na figura seguinte.
Figura 4: Lista de auto-completar de código para attr_a
Selecione attr_accessor :attr_names rw e
pressione Enter.
O IDE conclui o código e seleciona attr_names
para edição, como mostrado na próxima figura.
Figura 5: Código concluído
Digite id, :type, :price para
completar a instrução e pressione Enter.
A instrução deve se parecer com o seguinte código:
attr_accessor :id, :type, :price
Selecione cada um dos argumentos ao método
attr_accessor e observe como o
IDE realça o uso de cada atributo.
O script concluído deve se parecer com a seguinte amostra de código.
Amostra de código 2: classe Item formatado
class Item
attr_accessor :id, :type, :price
def initialize(id, type, price)
@id = id
@type = type
@price = price.to_f
end
def to_s
"Item #{@id} is a #{@type}: Price $#{@price}"
end
end
Criar a classe ItemsList
Na janela Projetos, crie outro arquivo de classe,
clicando com o botão direito do mouse no nó Arquivos de código-fonte e
escolhendo Novo > Classe Ruby no menu pop-up. Digite
ItemsList na caixa de texto Classe
e clique em Terminar. Observe que o IDE chama o arquivo de items_list.rb.
Substitua o conteúdo do arquivo items_list.rb
pelas seguintes instruções.
Amostra de código 3: classe ItemsList
class ItemsList
DATA_FILE="data.txt"
attr_accessor :items
def initialize
@items = ItemsList.load_item_data
end
private
def self.load_item_data
items = []
File.open(DATA_FILE) do |data_file|
data_file.readlines.each do |line|
items << Item.new(*line.split("\s"))
end
end
items
end
end
Abra uma linha acima da definição Classe e digite
require ' (aspa única).
Observe como o IDE fornece
a aspa única de fim e coloca o cursor
entre as aspas, como mostrado na figura
seguinte. O IDE insere automaticamente e remove
os delimitadores correspondentes, tais como
aspas, chaves,
e colchetes, assim como instruções end
dos blocos de código.
Figura 6: Correspondência de pares do delimitador
Com o cursor dentro das aspas únicas, digite it e pressione Ctrl-Espaço.
Existe apenas uma importação disponível que começa
com "it", item, como mostrado na próxima figura. Pressione
Tab para aceitar essa opção.
Figura 7: Auto-completar de código para a instrução require
Crie o arquivo de dados
Na janela Projetos ou Arquivos, clique com o botão direito do mouse no nó Arquivos-fonte e escolha Novo > Outro no menu pop-up.
Selecione Outro no painel Categorias, selecione Arquivo vazio no painel Tipos de arquivos e clique em Próximo.
Digite data.txt na
caixa de texto Nome do arquivo.
Garanta que a pasta esteja definida como
lib,
e clique em Terminar.
Observação: você está colocando o arquivo de texto
na pasta lib porque, por padrão,
quando executa o projeto a partir do IDE,
o diretório de trabalho padrão é a pasta lib.
Cole o texto seguinte no arquivo data.txt.
Amostra de código 4: dados do produto
BF15678 book 25.32
C29589 cd 18.95
F89028 beverage 2.00
BN98232 book 45.33
BF15890 book 15.98
Crie o script principal e execute a aplicação
Na janela Projetos, clique duas vezes em main.rb
para exibir o arquivo na janela do editor. Substitua
o conteúdo pelas instruções seguintes, que
exibem a lista de itens:
Amostra de código 5: conteúdo de main.rb
require 'items_list'
items_list = ItemsList.new
items_list.items.each do |item|
line_item = item.to_s
line_item.gsub!(/book/, 'fiction \0') if item.id =~ /\AB[FN]/
line_item.gsub!(/fiction/, 'non-\0') if item.id =~ /\ABN/
puts line_item
end
puts "\n"
O código que você acabou de copiar contém dois objetos Regexp;
/\AB[FN]/ e /\ABN/.
Coloque o cursor dentro de um dos objetos
Regexp, como mostrado abaixo, e pressione
Ctrl-Espaço. O IDE exibe uma lista de
caracteres de expressão regular
e combinações de caracteres. Observe
os dados na Amostra de código 5 e
deduza quais itens correspondem a cada duas
expressões
regulares.
Figura 8: Auto-completar de código da expressão regular
Para executar o projeto, clique no botão Executar projeto principal na barra de ferramentas principal.
O IDE salva todas as suas alterações e executa o script main.rb. A saída da aplicação é exibida na janela Saída, como mostrado na figura abaixo.
Figura 9: Saída de simple_ruby_application
Para praticar o que você aprendeu, crie outro
projeto Ruby. Faça o projeto ler e exibir
as entradas em uma lista de tarefas.
Criar um projeto Ruby on Rails no IDE é muito semelhante
a usar o comando rails em uma janela do terminal. Na verdade, quando você cria um projeto, o IDE cria as mesmas
pastas e arquivos que um comando rails criaria.
Crie um projeto, clicando com o botão direito do mouse na janela Projetos e escolhendo Novo projeto no menu pop-up. Selecione
Ruby no painel Categorias e
selecione Aplicação Ruby on Rails ou Aplicação Ruby on Rails
com códigos-fonte existentes no painel
Projetos.
Você pode ter vários projetos abertos no IDE ao mesmo tempo. O nó do projeto principal, que é o projeto em que o NetBeans atua, e mostrado em negrito. Para alternar
o projeto principal, clique com o botão direito do m ouse em um projeto na janela
Projetos e escolha Definir como projeto principal.
Como mostrado na figura seguinte, a segunda página do assistente para Novo projeto
permite que você nomeie o projeto e especifique sua localização.
Uma lista suspensa fornece os nomes de vários servidores de banco de dados suportados. O IDE usa o servidor de banco de dados selecionado,
assim como a opção Acessar banco de dados usando JDBC
para determinar como escrever o conteúdo do arquivo database.yml.
Figura 10: Página 2 do assistente para Novo projeto Ruby on Rails
Experimente
Siga estas etapas para criar um projeto Ruby on Rails.
Clique com o botão direito do mouse em um lugar vazio na janela Projetos e escolha Novo projeto no menu pop-up.
No assistente para Novo projeto, selecione Ruby no painel Categorias,
selecione Aplicação Ruby on Rails
no painel Projetos e clique em Próximo. Se este for o primeiro projeto Ruby que você abriu ou criou, deve aparecer uma caixa de diálogo pedindo para você escolher um intérprete Ruby. Selecione
uma das opções de intérprete e clique em OK.
Chame o projeto, por exemplo, de simple_rails_application.
Em seguida, escolha o servidor de banco de dados que você
usará com a aplicação. Se você estiver usando JRuby, deverá
escolher
MySQL, PostgresSQL, Oracle, HSQLDB ou Java DB (também conhecido como Derby).
O IDE usa esta informação para alimentar o arquivo
database.yml.
Observação: se planeja usar este projeto exclusivamente para este tutorial, você não estará acessando quaisquer bancos de dados, portanto, você pode aceitar as configurações de banco de dados padrão.
Se estiver usando JRuby e acessando um servidor de banco de dados diferente de MySQL, você deve marcar a caixa de verificação Acessar banco de dados usando JDBC.
Se o seu servidor de banco de dados for MySQL, o uso de JDBC é opcional.
Quando essa caixa de verificação é marcada, o IDE adicione instruções
ao arquivo environment.rb para usar o gem ActiveRecord-JDBC.
Observação: para usar uma conexão JDB, você deve obter um
driver de cliente JDBC 3.0 para seu servidor de banco de dados, e colocar
uma cópia do driver JDBC na pasta JRuby/lib.
Clique em Terminar.
Examine a visualização lógica da estrutura do arquivo na janela Projetos.
Clique com o botão direito do mouse no nó do projeto (o nó raiz do projeto)
e observe as opções do menu.
Clique na aba Arquivos e compare a estrutura desse arquivo físico com a visualização lógica apresentada na janela Projetos.
A figura seguinte mostra as janelas lado a lado,
para facilitar a comparação com duas visualizações.
Figura 11: Comparação da janela Projetos e da janela Arquivos
Clique com o botão direito do mouse no nó do projeto na janela Arquivos e observe as opções de menu diferentes, comparadas com o menu pop-up na janela Projetos.
Por exemplo, o menu pop-up do nó do projeto na
janela Projetos fornece a ação Gerar,
a ação Executar tarefa Rake e a ação Console Rails, além
de muitas outras ações específicas do Rails.
Trabalhando com arquivos Ruby on Rails
Além dos projetos Ruby, o suporte a Ruby do NetBeans permite que você trabalhe com projetos Ruby on Rails. Rails é um framework que permite que você crie rapidamente
aplicações Web de banco de dados que são baseadas na
arquitetura MVC (controlador de visualização de modelo).
Como nos projetos Ruby, você pode abrir um arquivo
no editor, clicando duas vezes no nó
do arquivo na janela Projetos ou
na janela Arquivos, ou pressionando
Alt-Shift-O (use Ctrl-Shift-O no Mac)
para acessar um arquivo por nome.
O menu pop-up dos nós na janela Projeto fornece acesso fácil
para scripts Rails e tarefas Rake, tais como o script
generate para gerar código,
e a tarefa db:migrate para migrar para
uma versão específica das tabelas do banco de dados.
O IDE entende os relacionamentos entre os tipos de arquivo, e facilita a navegação para os arquivos associados. Por exemplo, se você estiver editando um arquivo de visualização, use o menu pop-up para navegar para o arquivo ou teste da ação associada.
Como em todos os projetos do NetBeans, você pode executar sua aplicação, clicando no botão Executar projeto principal. O
IDE salva todas as alterações do arquivo, inicia o servidor da Web, se necessário,
em seguida, exibe a página de boas-vindas em seu navegador. Você também pode usar a ação do menu Executar arquivo
no editor para abrir no navegador a URL relevante
para qualquer controlador, ação, visualização ou helper que você esteja editando.
Experimente
Complete as etapas seguintes para criar uma versão Rails
do projeto de amostra apresentado na seção
Trabalhando com arquivos Ruby. Nesta variação,
o construtor usa um hash em vez
dos argumentos de posição,
você obtém os dados de um arquivo YAML,
e a funcionalidade ItemsList foi movida para a classe
Item.
Observação: geralmente, com um projeto Rails, você
baseia suas classes de modelo em tabelas de banco de dados. Entretanto, para tornar
esse exemplo rápido e simples, a aplicação obtém seus
dados a partir de um arquivo YAML.
Criar a classe Modelo
Crie um projeto Ruby on Rails, ou use aquele que você
criou na seção anterior.
Na janela Projetos, clique com o botão direito do mouse no nó Modelos e escolha Gerar código no menu pop-up.
A caixa de diálogo Gerador do Rails se abre, com o modelo
selecionado na lista suspensa Gerar,
como mostrado abaixo.
Figura 12: Gerador do Rails chamado a partir do nó Modelo
Digite
Item na caixa de texto Argumentos
e clique em OK.
O IDE cria um arquivo chamado item.rb e abre o arquivo
no editor. Um nó do arquivo aparece sob o nó Modelos
na janela Projetos. O IDE também cria um conjunto de testes
sob Teste de unidade, uma fixação de teste em Fixações de teste, e uma migração em Migrações de banco de dados > migrar.
Substitua o conteúdo do arquivo item.rb pelo
seguinte código.
Amostra de código 6: classe Item
# Takes:
# :id => unique item id
# :type => type of item
# :price => price of the item
class Item
DATA_FILE="data.yml"
attr_accessor :id, :type, :price
def initialize(attributes)
@id = attributes['id']
@type = attributes['type']
@price = attributes['price'].to_f
end
def to_s
"Item #{@id} is a #{@type}: Price $#{@price}"
end
def self.load_item_data
YAML.load_file(DATA_FILE).collect do |item_hash|
Item.new(item_hash)
end
end
end
Crie o arquivo de dados
A classe Item requer o arquivo data.yml
para seus dados. Para criar esse arquivo, clique com o botão direito do mouse no nó do projeto na janela Projetos, e escolha Novo > Outro no menu pop-up.
Na caixa de diálogo Novo arquivo, selecione Ruby no painel Categorias,
selecione o arquivo YAML no painel Tipos de arquivo, e clique em Próximo.
Digite dados na caixa de texto Nome do arquivo e clique em Terminar.
O IDE cria um arquivo chamado data.yml na pasta raiz do projeto, e abre o arquivo no editor. Como o arquivo
está na pasta raiz, você não o vê na visualização lógica
da janela Projeto. Entretanto, ele aparece
na janela Arquivos.
Substitua o conteúdo do arquivo data.yml pelo
texto seguinte.
Amostra de código 7: data.yml
-
id: BF15678
type: book
price: 25.32
-
id: C29589
type: cd
price: 18.95
-
id: F89028
type: beverage
price: 2.00
-
id: BN98232
type: book
price: 45.33
-
id: BF15890
type: book
price: 15.98
Crie o controlador e a visualização
O modelo está pronto. Agora, adicione o controlador e a visualização.
Na janela Projetos, clique com o botão direito do mouse no nó Controladores e escolha Gerar no menu pop-up.
A caixa de diálogo Gerador do Rails se abre com o controlador
selecionado na lista suspensa Gerar,
como mostrado abaixo.
Figura 13: Gerador Rails chamado do nó Controladores
Digite Item na caixa de texto Nome, digite
index na caixa de texto Visualizações, e clique em OK.
O IDE cria a classe ItemController e a visualização
index.rhtml, que está sob o nó
Visualizações > nó item. Além disso, o IDE cria
Testes funcionais > item_controller_test.rb e
Helpers > item_helper.rb.
Substitua o conteúdo do arquivo item_controller.rb pelo
seguinte código.
Amostra de código 8: classe ItemController
class ItemController < ApplicationController
def index
@items = Item.load_item_data
end
end
A ação index, que o controlador
chama antes de chamar a visualização índice,
preenche a matriz global @items
com a lista de itens.
Para acessar rapidamente o arquivo index.rhtml, clique com
o botão direito do mouse na definição do índice, e escolha Navegar > Ir para ação ou visualização do Rails no menu pop-up, como mostrado na figura seguinte.
Figura 14: Navegando para a visualização
Substitua o conteúdo de index.rhtml pela
marcação seguinte.
Amostra de código 9: index.rhtml
<h1>List of Items</h1>
<table border="1">
<tr><th>Id</th><th>Type</th><th>Price</th></tr>
<% for item in @items %>
<tr>
<td><%= item.id %>
</td>
<td><%= item.type %></td>
<td class="align-right"><%= '%.02f' % item.price %></td>
</tr>
<% end %>
</table>
O código Ruby que é incorporado no HTML itera sobre a matriz global @items que foi definida pela ação índice no controlador.
Execute a aplicação
Clique no botão Salvar tudo na barra de ferramentas principal para salvar todas as alterações.
Os asteriscos (*) nas abas do arquivo, que indicavam arquivos modificados,
desapareceram.
Clique com o botão direito do mouse no editor e escolha Executar arquivo.
O IDE envia a URL do controlador do item e da ação índice
para o servidor, que, por sua vez, envia a página seguinte
para o navegador.
Figura 15: Visualização Índice exibida no navegador
Tente clicar em Executar projeto principal para executar a aplicação inteira.
Observe que a página de boas vindas padrão do Ruby on Rails aparece. Isso acontece porque o
roteador, por padrão, exibe Público > arquivo index.html. Você
irá alterar o roteamento nas etapas seguintes.
Na janela Projetos, expanda Público.
Clique com o botão direito do mouse no nó index.html e escolha Excluir no menu pop-up.
Na janela Projetos, expanda o nó Configuração e clique duas vezes em routes.rb para abri-lo no editor.
Procure pelo comentário seguinte.
# map.connect '', :controller => "welcome"
Substitua o comentário seguinte mostrado em negrito.
Amostra de código 10: código de roteamento
# You can have the root of your site routed by hooking up ''
# -- just remember to delete public/index.html.
map.connect '', :controller => "item"
Para garantir que as alterações de roteamento são detectadas pelo servidor,
clique no botão Parar do servidor que aparece no
canto inferior direito do IDE, como mostrado abaixo.
Figura 16: Botão Parar do servidor
Clique em Executar projeto principal para iniciar a aplicação no navegador.
Praticando o que você aprendeu
Agora, tente construir um projeto do zero. Crie um projeto
Ruby on Rails que exiba as entradas em uma lista de tarefas.
O site do
Ruby on Rails
contém screencasts, apresentações, tutoriais e amostras.
Você pode usar a ferramenta Plug-ins para baixar
e instalar a aplicação de amostra Ruby Depot
(talvez ela já esteja instalada com a sua
versão do IDE). Depois da instalação do plug-in,
clique com o botão direito do mouse na janela Projetos e escolha Novo projeto
no menu pop-up. Expanda Amostras no painel Categorias
e selecione Ruby. Selecione Depot e clique em Próximo. Clique em
Terminar e siga as instruções no README que
aparece no navegador.
Usando o console Ruby (IRB) interativo do JRuby
Como você pode supor, o console Ruby interativo (IRB) do JRuby
é um módulo que permite que você indique instruções do Ruby interativamente,
como faz com o IRB do Ruby. Além disso, o console Ruby interativo
(IRB) do JRuby
fornece interoperabilidade com aplicações da plataforma Java.
Abra o console, escolhendo
Janela > Outro > Shell do Ruby (IRB) no menu principal. O
console aparece na parte inferior do IDE, como mostrado
na figura seguinte.
Figura 17: Console IRB do JRuby
O console IRB é iniciado a partir da pasta de instalação do NetBeans. Para alternar para outra pasta, digite o comando seguinte,
substituindo seu-caminho pelo caminho da pasta
que contém os arquivos do Ruby.
=> Dir.chdir("seu-caminho")
Escolher a janela do console não interrompe a sessão do IRB. Quando você reabre a janela, o histórico do comando permanece lá. Para interromper uma sessão, digite quit
ou exit no console.
Experimente
No menu principal, escolha Janela > Outro > Shell do Ruby (IRB)
para abrir o console do IRB.
Digite algumas constantes do Ruby para se familiarizar com o
ambiente, tais como PLATFORM,
VERSION, ENV_JAVA e ENV.
Digite Object::constants para ver todas as constantes de nível superior.
Use o IRB para experimentar as instruções do Ruby. Por exemplo,
digite as instruções seguintes para ver as saídas do Ruby:
Tente pensar em outras instruções do Ruby que você talvez queira
testar, como ver que tipo de exceção é lançada.
Experimente o recurso pop-up de auto-completar de código. Digite
os primeiros caracteres e pressione Tab para ver uma lista de sugestões,
como mostrado na figura seguinte. Você pode continuar digitando
para diminuir a lista. Selecione a sua opção
e pressione Enter.
Figura 18: Pop-Up de auto-completar de código
Pressione a Seta para cima várias vezes para rolar pelo
histórico do comando e pressione a Seta para baixo para mover-se para baixo. Pressione Return
para executar o comando novamente.
Para obter suporte e se manter informado sobre as alterações mais recentes nos recursos de desenvolvimento do NetBeans Ruby, participe das listas de usuários e .
),
o IDE salva todas as alterações e executa o script principal. Para alternar para um
script de inicialização diferente, clique com o botão direito do mouse no nó
Projeto na janela Projetos e escolha Propriedades
no menu pop-up. Selecione a categoria Executar e, no campo de texto
Script principal, digite o nome do arquivo.
