Rubysistsforjapan-badge

Este tutorial é uma rápida introdução ao Rails, que pretende ajuda-lo a entender como o framework funciona – e porque somos apaixonados por ele. Neste texto, você irá aprender alguns conceitos básicos do Rails, sua estrutura e como ele funciona, através de um exemplo prático. Lembro que você pode instalar o Rails facilmente no Windows usando o RailsInstaller.

Antes, uma breve introdução: O que é o Rails?
O Ruby on Rails é um framework projetado para agilizar o desenvolvimento de aplicações web, utilizando a linguagem Ruby. Ele possibilita que você concentre seus esforços em resolver o problema do seu cliente, deixando a parte (chata) da estrutura da aplicação por conta do framework.

Com o Rails, você não precisa se preocupar em montar a camada de acesso ao banco de dados quando iniciar um projeto. Nem como irá organizar os arquivos que irão compor a aplicação. Seguindo o “Rails Way” (ou o “modo Rails” de fazer as coisas) você irá ganhar em tempo e produtividade. Basta respeitar as convenções, ou seja, as regras do Rails. Essas são as vantagens de usar um bom framework: O trabalho não começa do zero, e você tem que seguir padrões, obrigando a organizar-se. Acredite, isso vai ajudar bastante no trabalho em equipe, na manutenção do código, ou caso outro desenvolvedor assuma o projeto futuramente.

Falando em organização, o Rails utiliza o padrão MVC, que divide a aplicação em partes com funções bem definidas. É importante entender o que é o MVC, pois isso irá ajudar a compreender a lógica do Rails.

MVC (Model-View-Controller)
Nas palavras da Wikipedia, o MVC “é um padrão de arquitetura de software que visa a separar a lógica de negócio da lógica de apresentação, permitindo o desenvolvimento, teste e manutenção isolado de ambos“. Como as aplicações estão cada vez mais complexas, tornou-se importante separar o acesso aos dados/lógica de negócios (model), interface (view), e interação (controller). Isso facilita bastante a manutenção do código e deixa a estrutura da aplicação bem organizada.

Model (modelo)
A camada do modelo é onde estão as classes para as entidades que sua aplicação possui. Considere como exemplo um blog: queremos armazenar os artigos em posts – então teremos um modelo “post”. Podemos implementar comentários também – então teremos um modelo “comentario”. Autores irão escrever os posts – então teremos o modelo “autor”. No Rails, entre outras coisas, o modelo gerencia os relacionamentos, as validações de dados e faz a comunicação com o banco de dados, recuperando e armazenando informações, graças a biblioteca ActiveRecord.

View (visão)
A visão (view), como o nome diz, é responsável pela parte visual da aplicação, onde o usuário faz as requisições (ao clicar num botão, por exemplo) e também onde são apresentadas as informações de resposta. Anview trabalha com HTML e comandos Ruby misturados em arquivos erb (Embedded Ruby), de forma semelhante ao PHP ou ASP. Por conta disso, você vai perceber que os arquivos da view são terminados com *.html.erb. As visões estão constantemente enviando e recebendo informações do controle – a camada C do MVC.

Control (controle)
Alguém deve fazer o meio de campo entre o model e a view: esse é o papel do controle. Podemos dizer que o controle é quem faz as coisas acontecerem dentro do MVC, pois ele recebe a ação da view, pesquisa (ou trata) o resultado junto ao model e devolve o resultado para a view, fazendo girar o ciclo de atividades dentro do MVC.

Caso queira aprender mais sobre MVC, uma busca no Google vai oferecer artigos mais profundos e esclarecedores sobre esse padrão. Mas para você aprender de verdade, nada como colocar a mão na massa; Então vamos prosseguir.

O cardápio do dia
Nesse tutorial, não vamos inventar muito: iremos montar um blog, pois provavelmente você já acessou algum e conhece como ele funciona. Isso torna mais simples assimilar algumas coisas. E caso nunca tenha acessado um blog, voilá! O RubyBrasil é um blog – com esteróides.

Esse será o resultado do tutorial

Antes de começar, é necessário ter em mente a estrutura da nossa aplicação de exemplo. Um blog pode ter posts, autores que escrevem os posts e comentários sobre os posts. Posts também podem pertencer a categorias e serem identificados por tags. Mas para que esse artigo não fique muito extenso, vamos simplificar: teremos apenas posts e comentários no nosso exemplo. Importante: Tenha em mente que um post pode ter vários comentários, entretanto cada comentário pertence a um post.

Criando um novo projeto
Chegou a hora de começar, criando nosso projeto. No Rails, um projeto é uma estrutura de pastas usada para armazenar os arquivos que irão compor sua aplicação. Uma ferramenta essencial durante o desenvolvimento Rails é o prompt de comandos (no windows) ou o terminal (no linux). Para criar nosso projeto, acesse o prompt de comando ou terminal e digite o comando abaixo.

$ rails new blog

Este comando irá fazer com que o Rails crie um diretório chamado blog, e monte dentro dele uma estrutura padrão de pastas e arquivos. Os mais importantes para nós, por enquanto, são esses:

Arquivo Função
config\database.yml Contém informações para conexão da aplicação com o banco de dados, como login e senha do SGBD.
config\routes.rb Arquivo onde definimos como as requisições HTTP serão roteadas.
app\controllers\ Contém os arquivos escritos em Ruby da camada controle (o C do MVC).
app\helpers\ Contém os helpers, classes que facilitam algumas tarefas (como criar formulários).
app\models\ Contém os arquivos escritos em Ruby da camada model (o M do MVC).
app\views\ Contém uma pasta para cada controle que sua aplicação tiver.
db\migrate\ Contém os arquivos de migração, usados para migrar o banco de dados de um estado para outro.

.

Acelerando o desenvolvimento com scaffold
Scaffold, em inglês, significa andaime. É o termo certo para o que ele faz: Cria a estrutura básica de um elemento dentro do seu projeto para que possamos desenvolver a aplicação. Num comando simples, o scaffold gera o modelo, o controle, e as visões (dentre outras coisas), adiantando bastante o seu trabalho. O scaffold pode ser usado também para construir protótipos rápidos, para mostrar ao seu cliente o andamento do trabalho.

Usando scaffold para criar os posts
Para criar os arquivos necessários para gerenciar os posts do nosso blog usando scaffold, primeiro devemos acessar a pasta da nossa aplicação.

$ cd blog/

Depois, estando dentro do diretório blog, basta uma única linha de comando. Nosso post terá o nome do autor, o titulo do post, e o conteúdo.

$ rails generate scaffold post titulo:string conteudo:text

Atente-se ao padrão do comando, que é formado pelo nome do modelo (post), seguido dos campos com seus respectivos tipos de dados (por exemplo, titulo:string e conteudo:text).

Como dito antes, esse comando gera um monte de arquivos. Ele cria o modelo chamado post.rb na pasta app/models, o posts_controller.rb (no plural) na pasta app/controllers, além de criar também as visões na pasta app/views. Ressalto que o Rails organiza as views através de pastas com o nome dos modelos existentes. Então, o scaffold vai gerar uma pasta dentro de app/views com o nome posts, contendo quatro arquivos dentro dela: index.html.erb, edit.html.erb, show.html.erb e new.html.erb. Ou seja, o Rails já criou uma view para algumas ações básicas relacionadas ao item post.

Usando scaffold para criar os comentários
Da mesma forma como criamos os posts, vamos criar também os comentários usando scaffold, através do comando abaixo.

$ rails generate scaffold comentario autor:string conteudo:text post:references

Desta vez, temos algo diferente no fim do comando. Informamos que cada comentário faz referência a post. Isso vai ajudar o Rails a montar o relacionamento entre as tabelas no banco de dados. O Rails saberá que deve criar um campo de chave estrangeira na tabela comentarios, ligando com a chave primária da tabela posts.

Relacionando os modelos Post e Comentario
No banco de dados está tudo OK, mas ainda será necessário explicitar o relacionamento entre post e comentario nos modelos das entidades. Para isso, acesse a pasta app/models e faça uma alteração no arquivo post.rb.

Abra o arquivo e acrescente nele a informação de que há muitos comentários para cada post.

1
2
3
class Post < ActiveRecord::Base
  has_many :comentarios
end

O arquivo comentario.rb, como foi criado por último e recebeu o post:references em sua definição, já possui a informação de que cada comentário pertence a um post, como você pode conferir.

1
2
3
class Comentario < ActiveRecord::Base
  belongs_to :post
end

No model comentario.rb não será necessário mexer. Mas logo você verá como será simples fazer com que cada post identifique seus comentários (e vice-versa) graças a esses pequenos comandos milagrosos.

E o banco de dados?
Você pode deixar o gerenciamento do banco de dados nas mãos do Rails. Em alguns casos, vai ser preciso configurar o arquivo database.yml com as informações do banco de dados que deseja utilizar. A partir de então, outras tarefas como criar tabelas, colunas, etc recomenda-se que sejam feitas a partir do Rails, para maior controle.

No nosso caso, vamos usar o banco de dados SQLite, que já vem configurado por padrão quando criamos uma aplicação Rails. Caso você quisesse usar outro banco de dados, como o MySQL, poderia ter informado já na criação da aplicação, como valor do parâmetro d.

$ rails new blog -d mysql

Continuando nossa missão, vamos mandar o Rails criar o banco de dados da aplicação, usando o comando Rake.

$ rake db:create

Pronto, temos nosso banco de dados SQLite criado. Se fosse um MySQL ou qualquer outro que ele suporte, seria a mesma coisa: também teríamos criado a base de dados da mesma forma com esse comando.

As migrações
No Rails, migração é a mudança do banco de dados de um estado para outro. Por exemplo, ao criar uma nova tabela, você altera o estado do banco de dados. Ao incluir/excluir uma coluna de determinada tabela, você altera o estado do banco de dados. Ou seja, alterações na estrutura do banco mudam seu estado, e as migrações permitem que você volte o banco de dados a estados anteriores, desfazendo alterações mal-sucedidas ou desnecessárias.

Quando usamos o scaffold para criar o post e o comentário, também foram criadas suas respectivas migrações, contendo as alterações que serão necessárias fazer ao banco de dados (como criar as tabelas com as colunas informadas). As migrações podem ser conferidas na forma de arquivos individuais na pasta db/migrate.

Vamos executar as migrações pendentes para que os modelos post e comentario possam armazenar seus respectivos dados no banco.

$ rake db:migrate

O Rake é uma ferramenta muito útil no ecossistema do Rails, com várias funções. Você pode aprender mais sobre ele na documentação do Rails.

Vamos ver como está?
Nesse momento, já é possível ver como está ficando nossa aplicação, inclusive testar seu funcionamento. Como o Rails é voltado para aplicações web, será necessário usar um servidor web para rodar o sistema. O próprio Rails possui um servidor chamado Webrick, que serve justamente para ajudar o desenvolvedor a acompanhar o progresso da aplicação.

Inicie o servidor com o comando abaixo no prompt/terminal:

$ rails server

Agora, abra o navegador web de sua preferência e acesse o endereço http://localhost:3000/posts para ver o que aparece. Localhost é o endereço local de sua máquina, 3000 é a porta que o servidor Webrick normalmente usa e posts é o nome do controle que desejamos acessar. Por padrão, essa URL irá acionar o método “index” de posts_controller.rb, que por sua vez utilizará a visão “index.html.erb” dentro da pasta app/views/posts.

Quando você clica no link New Post, o navegador acessa o endereço http://localhost:3000/posts/new, que contém um formulário para adicionar novos posts. Nesse momento, você está acionando o método “new” de posts_controller.rb, que irá chamar a visão “new.html.erb” na pasta app/views/posts.

Ao clicar no botão Create Post, seu post será salvo e o navegador redirecionado à URL http://localhost:3000/posts/show/1, que mostra os detalhes do post. Essa URL chama o metodo “show” do controle posts_controller.rb, passando como valor o id do post cujos detalhes deverão ser mostrados. No caso, está sendo apresentado o detalhe do post de código “1″, através da view “show.html.erb“.

Clique em “New Post” e faça alguns cadastros. Teste os links “Show“, “Edit” e “Destroy“. Tudo funcionando. Por isso que o Ruby on Rails faz tanto sucesso. Até aqui, temos um cadastro de posts plenamente funcional, feito em pouco tempo e com meia dúzia de comandos simples. Caso queira encerrar o servidor e liberar o prompt/terminal, tecle Control + C.

As rotas levam ao post
O endereço da nossa aplicação não está muito intuitivo, pois temos que digitar o nome do controle que queremos acessar (posts). Vamos configurar a aplicação de forma que digitando apenas http://localhost:3000/, o Rails saiba redirecionar para o controle de posts. Quando o objetivo é configurar o direcionamento das páginas, dizemos que é uma mudança de roteamento. Essas configurações estão no arquivo config/routes.rb.

Para que possamos eliminar a necessidade de colocar o controle posts no endereço, temos que fazer duas coisas. A primeira é deletar o arquivo public/index.html, que é criado automaticamente junto com o projeto. Esse arquivo tem apenas as informações sobre a versão do Rails e o ambiente de instalação, e temos que exclui-lo para poder avaliar o resultado da configuração das rotas.

A segunda coisa a fazer é configurar as rotas no arquivo config/routes.rb. Abra o arquivo no seu editor favorito e adicione uma linha definindo qual o controle#método será root, como mostramos abaixo. Nessa configuração, dissemos ao Rails que queremos na página inicial do site o método index do controle posts.

1
2
3
4
5
Blog::Application.routes.draw do
  resources :comentarios
  resources :posts
  root :to => "posts#index" #linha adicionada
end

Perceba que removemos as linhas de comentário para facilitar o entendimento do que deve ser alterado nesse arquivo.

As rotas levam aos comentários
Aproveitando que estamos configurando as rotas, vamos fazer outra alteração. Até o momento, para nossa aplicação Rails, posts estão numa página, e comentários em outra. Mas não é esse nosso interesse realmente. Queremos colocar os comentários na mesma página do seu post correspondente, para que seja mais simples de serem visualizados – como costumamos ver por aí nos blogs.

A alteração a ser feita é bem simples: basta dizer às rotas que o ‘recurso’ post contém o ‘recurso’ comentários.

1
2
3
4
5
6
Blog::Application.routes.draw do
   resources :posts do
      resources :comentarios
   end
   root :to => "posts#index"
end

Preparando a visão para receber os comentários
Será necessário modificar a visão show dos posts (arquivo app/views/posts/show.html.erb) para que ela mostre, além do conteúdo dos posts, também os comentários cadastrados relacionados a ele e o formulário para adicionar novos comentários.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
<p class="notice"><%= notice %></p>
 
<p>
  <b>Titulo:</b>
  <%= @post.titulo %>
</p>
 
<p>
  <b>Conteudo:</b>
  <%= @post.conteudo %>
</p>
 
<h2>Comentarios</h2>
<% @post.comentarios.each do |comentario| %>
  <p>
    <b>Autor:</b>
    <%= comentario.autor %>
  </p>
 
  <p>
    <b>Comentario:</b>
    <%= comentario.conteudo %>
  </p>
<hr />
<% end %>
 
<h2>Adicione um comentario:</h2>
<%= form_for([@post, @post.comentarios.build]) do |f| %>
  <div class="field">
    <%= f.label :autor %><br />
    <%= f.text_field :autor %>
  </div>
  <div class="field">
    <%= f.label :conteudo %><br />
    <%= f.text_area :conteudo %>
  </div>
  <div class="actions">
    <%= f.submit %>
  </div>
<% end %>
 
<br />
 
<%= link_to 'Edit Post', edit_post_path(@post) %> |
<%= link_to 'Back to Posts', posts_path %>

Resista à tentação de cadastrar algum comentário nesse instante, pois o controle comentarios_controller.rb ainda não está pronto para receber seu comentário. Essa é a próxima etapa.

Modificando o controle comentario
Vamos preparar o controle dos comentários para que ele saiba o que fazer quando algum usuário enviar sua opinião através do formulário. Inicialmente, remova os métodos criados por padrão – não vamos precisar deles. Adicione um novo método chamado “create“, como mostra o código abaixo. Esse simples código irá salvar o comentário no banco de dados, já relacionando-o com o post correspondente. Vamos aproveitar e incluir também um método para excluir os comentários indesejados, com o nome de destroy.

1
2
3
4
5
6
7
8
9
10
11
12
13
class ComentariosController < ApplicationController
   def create
    @post = Post.find(params[:post_id])
    @comentario = @post.comentarios.create(params[:comentario])
    redirect_to post_path(@post)
   end
   def destroy
    @post = Post.find(params[:post_id])
    @comentario = @post.comentarios.find(params[:id])
    @comentario.destroy
    redirect_to post_path(@post)
  end
end

Após essas alterações, atualize o navegador para ver como ficou (veja no terminal/prompt se o servidor ainda está rodando). Cadastre alguns comentários para ver funcionando.

Validação no modelo para evitar posts vazios
Apesar do visual não muito parecido com um blog, nossa aplicação já está funcional. Mas vamos aproveitar para conhecer mais algumas funcionalidades que o Rails oferece para nós. Uma delas é a validação de dados, evitando que sua aplicação receba dados inconsistentes. As validações estão relacionadas diretamente aos dados, dessa forma elas são feitas nos modelos.

Vamos aplicar uma validação para que não seja aceito post sem título e sem conteúdo. Até porque um post sem titulo e sem conteúdo não é um artigo válido, certo? Abra o modelo app/models/post.rb e adicione as validações, conforme abaixo.

1
2
3
4
5
class Post < ActiveRecord::Base
   has_many :comentarios
   validates :titulo, :presence => true, :length => { :minimum => 10 }
   validates :conteudo, :presence => true
end

Acabamos de definir que a presença do titulo é obrigatória, além de que deverá ter 10 caracteres no mínimo. O conteúdo apenas tem que obrigatoriamente ser preenchido.

Implementando segurança
Aproveitando outra funcionalidade que o Rails oferece – autenticação HTTP – vamos estabelecer duas simples regras de segurança no nosso blog. Primeiro: Para adicionar um post, o usuário tem que autenticar-se com login e senha. Segundo: Para apagar um comentário, também será necessário autenticação.

Essa regra vai incidir sobre os controles, pois as autenticações serão solicitadas apenas em determinadas ações (métodos). Em vez de implementarmos essa regra no posts_controller.rb e depois repeti-la nos comentarios_controller.rb, vamos adiciona-la uma única vez num lugar onde toda a aplicação poderá enxerga-la. Esse lugar é o application_controller.rb, o super-controle cujas regras atingem toda aplicação. Ele evita que você fique espalhando a mesma instrução em vários controles diferentes.

Acesse o arquivo em app/controllers/application_controller.rb e adicione as seguintes linhas:

1
2
3
4
5
6
7
8
9
10
11
12
class ApplicationController < ActionController::Base
  protect_from_forgery
 
  private
 
  def autenticacao
    authenticate_or_request_with_http_basic do |usuario, senha|
      usuario == 'admin' && senha == 'abracadabra'
    end
  end
 
end

Nas linhas acima, definimos uma regra de autenticação, e já configuramos qual será o usuário/senha. Agora temos que sair inserindo onde essa autenticação será necessária.

A primeira autenticação vai ficar nos posts. Abra o controle app/controllers/posts_controller.rb e acrescente a regra de autenticação logo abaixo da definição de classe. Não apague nada do que está lá, pois os outros métodos ainda serão utilizados.

1
2
3
4
5
6
class PostsController < ApplicationController
   before_filter :autenticacao, :except => [:index, :show] # linha adicionada
 
  # GET /posts
  # GET /posts.xml
...

Perceba que usamos :except, ou seja, a validação será requerida em todos os métodos exceto index e show. Será solicitado usuário/senha para adicionar, editar e excluir posts.

Agora no controle dos comentários, adicionaremos também a validação. Desta vez, usaremos o parâmetro : only em vez de :except. Abra o app/controllers/comentarios_controller.rb e adicione a linha com a validação.

1
2
3
class ComentariosController < ApplicationController
   before_filter :autenticacao, :only => [:destroy] # linha adicionada
...

Melhorando o visual
Por fim, vamos mexer na aparência de nossa aplicação, pois ela parece várias coisas, menos um blog. Como você deve se lembrar do nosso discurso sobre MVC, a parte responsável pelo visual é a view. Nesse exemplo, iremos fazer uma plástica as duas visões mais requisitadas, a index e a show.

Abra a visão index do post (app/views/posts/index.html.erb), e substitua o código padrão que está lá por este:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<h1>Meu Blog</h1>
 
<% @posts.each do |post| %>
<h2><%= link_to post.titulo, post %></h2>
<p><%= post.conteudo %></p>
<%= link_to 'Ver mais', post %>
<%= link_to '[Editar]', edit_post_path(post) %>
<%= link_to '[Excluir]', post, :confirm => 'Tem certeza?', :method => :delete %>
<hr />
<% end %>
 
<br />
 
<%= link_to 'Novo Post', new_post_path %>

Essas poucas linhas irão resolver. Caso você tenha vários posts cadastrados, já perceberá a diferença.

Agora abra a visão show do post (app/views/posts/show.html.erb) e troque o código que está lá por este.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
<h1>Meu Blog</h1>
<p class="notice"><%= notice %></p>
 
<h2><%= @post.titulo %></h2>
<p><%= @post.conteudo %></p>
 
<h3>Comentarios</h3>
<% @post.comentarios.each do |comentario| %>
  <p>
    <b>Autor:</b>
    <%= comentario.autor %>
  </p>
 
  <p>
    <b>Comentario:</b>
    <%= comentario.conteudo %>
  </p>
<p>
  <%= link_to 'Apagar Comentario', [comentario.post, comentario],
               :confirm => 'Tem certeza?',
               :method => :delete %>
</p
<hr />
<% end %>
 
<h3>Adicione um comentario:</h3>
<%= form_for([@post, @post.comentarios.build]) do |f| %>
  <div class="field">
    <%= f.label :autor %><br />
    <%= f.text_field :autor %>
  </div>
  <div class="field">
    <%= f.label :conteudo %><br />
    <%= f.text_area :conteudo %>
  </div>
  <div class="actions">
    <%= f.submit %>
  </div>
<% end %>
 
<br />
 
<%= link_to 'Editar Post', edit_post_path(@post) %> |
<%= link_to 'Voltar aos Posts', posts_path %>

Pronto! Temos um blog funcional desenvolvido em Rails.

O que falta?
Falta trabalhar os menus, um sistema de autenticação mais profissional, um layout mais interessante… Só não falta vontade de aprender, tenho certeza. Com o conhecimento adquirido até aqui, você já é capaz de descobrir muitas coisas sozinho. Reforce seu conhecimento com outros recursos online, eles irão aprofundar mais nos conceitos que abordamos superficialmente.

Além disso, você pode aprender também através de livros. Recomendo o recém-lançado Rails 3 Básico, que você pode comprar com um super desconto na loja virtual da Novatec. O livro é voltado para iniciantes e, apesar do nome, vai além do básico. O conteúdo é bem atualizado e a didática é excelente, tenho certeza de que você irá aprender bastante com ele.

Artigos relacionados

Tags:
 

47 Responses to Tutorial: Criando sua primeira aplicação com Rails

  1. Silfar disse:

    Muito bom.

    Mas porque parar por aqui ?

    Seria muito legal se você desse continuidade como uma série, tornando o exemplo mais avançado.

    Abraços.

  2. Rogerio disse:

    Concordo com o Silfar, o conteúdo esta tão bom que merece continuação. Pense nisso.
    Abraços e parabéns pelo trabalho.

  3. [...] http://ruby-br.org/?p=2165 Arquivado em Sem categoria ← Instalando Flash no 11.04 64 Bits LikeBe the first to like this post. [...]

  4. [...] 3, para conhecer um pouco mais sobre o framework. Novamente o objetivo é reforçar os conceitos apresentados no texto anterior, além de aprender mais alguns truques interessantes do [...]

  5. Luiz Cezer disse:

    Muito bom tutorial pra quem inicia, eu mesmo já conheço e trabalho com o frameworks a algum tempo e implementei o tutorial, muito bom mesmo ! :)

  6. Pablo Lima disse:

    Amigo estou com problemas na hora de startar o servidor.

    Segui os passos direitinho mas ta dando esse erro:

    rvm/rubies/ruby-1.9.2-p290/lib/ruby/1.9.1/webrick/utils.rb:73:in `initialize’: Address already in use – bind(2) (Errno::EADDRINUSE)

    to usando o rails 3.1.0. Tem ideia de como resolver esse problema?

    Grato,

    Pablo LIma

    • alvaro disse:

      Você já tem algum server rodando na sua máquina?

    • Gilberto disse:

      Mata o processo… já tens um server rodando…

      digita no terminal:
      lsof -wni tcp:3000

      Aí tu acha o PID do processo… pega esse PID e digita:
      kill -9 NÚMERO_PID

      OBS.: substituir o NÚMERO_PID pelo numero do teu processo…

  7. Ybur disse:

    Muito bom cara, parabéns pelo trabalho…como dito antes, merece muito uma continuação….força!!!

  8. Rodrigo disse:

    Tutorial excelente, trabalho com cakephp e estou estudando rails e esse tutorial me ajudou muito.

  9. Ludimila disse:

    Muito bom o tutorial!

  10. Cledson Santos disse:

    Parabéns …pelo trabalho !

    Queria saber se tem como e como seria pra fazer a tela de autenticação do usuário, não escrevendo a senha e loguin do mesmo no programa, mais sim baseado em um banco de dados ?

  11. Ana Paula disse:

    Muito bom este tutorial! Parabéns!!!

  12. Tito Junior disse:

    Cara muito bom, parabéns como outros colegas já disseram você deveria da sequencia em uma série de artigos.

  13. Aristóteles disse:

    Muito Bom mano, me ajudou bastante !!! Continue o artigo !!! Vlw

  14. Marcelo disse:

    Bom muito bom ate eu que nunca tinha visto .. ja me intericei .. de estar estudando .. obrigado vc me ajudo muito mesmo !!!

  15. [...] Criando sua primeira aplicação com Rails – Ótimo tutorial para começar com Rails [...]

  16. Johnny disse:

    Parabéns pelo tutorial!

    Definitivamente o mais esmiuçado para os “primeiros passos” com Rails!

    Agora é só “brincar” na linguagem!

  17. Raphael disse:

    Muito bom tutorial, bem esmiuçado e de execução tranquila. Foi minha primeira aplicação em Ruby e com certeza recomendo a quem quer a coisa desde o básico, assim como eu.
    Obrigado pelo seu emprenho em ajudar as pessoas que pretendem aprender.

  18. kaio disse:

    Kra demais, tive um pequeno problema ainda com o libmysql.dll, que da( ainda to tento arrumar)erro, mas pra não desanimar baixar o SQlite deu certo. Valeu mesmo.

  19. gilvam disse:

    Muito bom!
    Ainda tentando resolver algum problema com uso do tutorial para ruby 2 e rails 4.

  20. Fabio disse:

    Estou com um pequeno problema:

    ActiveModel::MassAssignmentSecurity::Error in PostsController#create
    Can’t mass-assign protected attributes: titulo, conteudo

    Sabe o que pode ser?

    Ótimo tutorial.

  21. Andre Luis disse:

    Tambem meu primeiro Tutorial… muito bom! continuação..?

  22. Matheus disse:

    Iniciei meus estudos sobre Ruby on Rails semana passada, ao tentar rodar a aplicação do tutorial é exibido o seguinte erro no browser, algumé sabe dizer como resolver? Obrigado.

    Showing C:/Users/Micro61/blog/app/views/posts/index.html.erb where line #12 raised:

    undefined method `each’ for nil:NilClass

    Extracted source (around line #12):

    9:
    10:
    11:
    12:
    13:
    14:
    15:

  23. Fabio Crispim disse:

    Ao executar :
    rails generate scaffold post titulo:string conteudo:text

    tenho o seguinte erro:

    /var/lib/gems/1.9.1/gems/execjs-1.4.0/lib/execjs/runtimes.rb:51:in `autodetect’: Could not find a JavaScript runtime. See https://github.com/sstephenson/execjs for a list of available runtimes. (ExecJS::RuntimeUnavailable)
    from /var/lib/gems/1.9.1/gems/execjs-1.4.0/lib/execjs.rb:5:in `’
    from /var/lib/gems/1.9.1/gems/execjs-1.4.0/lib/execjs.rb:4:in `’
    from /var/lib/gems/1.9.1/gems/coffee-script-2.2.0/lib/coffee_script.rb:1:in `require’
    from /var/lib/gems/1.9.1/gems/coffee-script-2.2.0/lib/coffee_script.rb:1:in `’
    from /var/lib/gems/1.9.1/gems/coffee-script-2.2.0/lib/coffee-script.rb:1:in `require’
    from /var/lib/gems/1.9.1/gems/coffee-script-2.2.0/lib/coffee-script.rb:1:in `’
    from /var/lib/gems/1.9.1/gems/coffee-rails-3.2.2/lib/coffee-rails.rb:1:in `require’
    from /var/lib/gems/1.9.1/gems/coffee-rails-3.2.2/lib/coffee-rails.rb:1:in `’
    from /var/lib/gems/1.9.1/gems/bundler-1.3.5/lib/bundler/runtime.rb:72:in `require’
    from /var/lib/gems/1.9.1/gems/bundler-1.3.5/lib/bundler/runtime.rb:72:in `block (2 levels) in require’
    from /var/lib/gems/1.9.1/gems/bundler-1.3.5/lib/bundler/runtime.rb:70:in `each’
    from /var/lib/gems/1.9.1/gems/bundler-1.3.5/lib/bundler/runtime.rb:70:in `block in require’
    from /var/lib/gems/1.9.1/gems/bundler-1.3.5/lib/bundler/runtime.rb:59:in `each’
    from /var/lib/gems/1.9.1/gems/bundler-1.3.5/lib/bundler/runtime.rb:59:in `require’
    from /var/lib/gems/1.9.1/gems/bundler-1.3.5/lib/bundler.rb:132:in `require’
    from /home/crispim/blog/config/application.rb:7:in `’
    from /var/lib/gems/1.9.1/gems/railties-3.2.13/lib/rails/commands.rb:24:in `require’
    from /var/lib/gems/1.9.1/gems/railties-3.2.13/lib/rails/commands.rb:24:in `’
    from script/rails:6:in `require’
    from script/rails:6:in `’

    Não passo para a outra fase… podes me explicar por favor o que tem de errado?

  24. Flávio disse:

    Parabéns, é bom ver conteúdo funcional e bem explicativos como esse, depois de pegar alguns que sempre tinha comando que não funcionava tava achando chato ficar procurando por algo bem explicativo e funcional como achei aqui, então parabéns.

  25. Fabio Crispim disse:

    Estou com o seguinte problem ao executar o comando

    $ rails generate scaffold post titulo:string conteudo:text
    Apos executar o comando tenho :
    [fcrispim@localhost blog]$ rails generate scaffold comentario autor:string conteudo:text post:references
    /usr/share/ruby/yaml.rb:6:in `’:
    It seems your ruby installation is missing psych (for YAML output).
    To eliminate this warning, please install libyaml and reinstall your ruby.
    /usr/share/ruby/yaml.rb:7:in `require’: cannot load such file — psych (LoadError)
    from /usr/share/ruby/yaml.rb:7:in `’
    from /usr/local/share/gems/gems/activesupport-3.2.13/lib/active_support/ordered_hash.rb:6:in `require’
    from /usr/local/share/gems/gems/activesupport-3.2.13/lib/active_support/ordered_hash.rb:6:in `’
    from /usr/local/share/gems/gems/activesupport-3.2.13/lib/active_support/ordered_options.rb:1:in `require’
    from /usr/local/share/gems/gems/activesupport-3.2.13/lib/active_support/ordered_options.rb:1:in `’
    from /usr/local/share/gems/gems/railties-3.2.13/lib/rails/configuration.rb:2:in `require’
    from /usr/local/share/gems/gems/railties-3.2.13/lib/rails/configuration.rb:2:in `’
    from /usr/local/share/gems/gems/railties-3.2.13/lib/rails/railtie.rb:2:in `require’
    from /usr/local/share/gems/gems/railties-3.2.13/lib/rails/railtie.rb:2:in `’
    from /usr/local/share/gems/gems/railties-3.2.13/lib/rails/engine.rb:1:in `require’
    from /usr/local/share/gems/gems/railties-3.2.13/lib/rails/engine.rb:1:in `’
    from /usr/local/share/gems/gems/railties-3.2.13/lib/rails/plugin.rb:1:in `require’
    from /usr/local/share/gems/gems/railties-3.2.13/lib/rails/plugin.rb:1:in `’
    from /usr/local/share/gems/gems/railties-3.2.13/lib/rails/application.rb:3:in `require’
    from /usr/local/share/gems/gems/railties-3.2.13/lib/rails/application.rb:3:in `’
    from /usr/local/share/gems/gems/railties-3.2.13/lib/rails.rb:10:in `require’
    from /usr/local/share/gems/gems/railties-3.2.13/lib/rails.rb:10:in `’
    from /usr/local/share/gems/gems/railties-3.2.13/lib/rails/all.rb:1:in `require’
    from /usr/local/share/gems/gems/railties-3.2.13/lib/rails/all.rb:1:in `’
    from /home/fcrispim/blog/config/application.rb:3:in `require’
    from /home/fcrispim/blog/config/application.rb:3:in `’
    from /usr/local/share/gems/gems/railties-3.2.13/lib/rails/commands.rb:24:in `require’
    from /usr/local/share/gems/gems/railties-3.2.13/lib/rails/commands.rb:24:in `’
    from script/rails:6:in `require’
    from script/rails:6:in `’

    Já instalei a libyaml e reintalei o ruby … porem nada… Podem me ajudar.
    Fedora 19.

    • Luiz Paulo Franz disse:

      Cara, você esta desenvolvendo o projeto com o Netbeans? Aqui acontecia isso quando eu criava um projeto Netbeans pra desenvolver, não sei pq…

  26. Gustavo disse:

    Muito obrigado, excelente tutorial! Meus parabéns!

  27. eduardo disse:

    nao consigo achar o arquivo public/index.html para deletar

  28. Luiz Paulo Franz disse:

    Pra quem ta usando Rails 4+ vai dar erro ActiveModel::ForbiddenAttributesError, pelo menos aqui deu, se isso ocorrer, o conteudo do arquivo comentarios_controller.rb deve ser:

    class ComentariosController < ApplicationController
    def create
    @post = Post.find(params[:post_id])
    @comentario = @post.comentarios.create(comment_params)
    redirect_to post_path(@post)
    end
    def destroy
    @post = Post.find(params[:post_id])
    @comentario = @post.comentarios.find(params[:id])
    @comentario.destroy
    redirect_to post_path(@post)
    end

    private

    def comment_params
    params.require(:comentario).permit(:autor, :conteudo)
    end
    end

  29. Diel disse:

    Muito bom, parceiro… Gostaria de ver mais posts seus.
    Obrigado!

  30. Augusto disse:

    Primeiramente gostaria de te parabenizar pelo post. Ficou muito bom!

    Estou tentando desenvolver o que foi proposto, sendo que no Rails 4, mas estou com um problema no arquivo show.html.erb, mais especificamente na na linha de comando:

    Alguém poderia me ajudar?

    Já fiz o ajuste que o nosso colega Luiz Paulo Franz recomendou mas o erro permanece.

    PS.: Sou iniciante no mundo Rails.

    Abraço e sucesso!

  31. Show de bola esse post heim, eu mesmo ja implementei esse tutorial quando comecei com Ruby e Ruby on Rails e para mim foi muito importante.

    Valew pela ajuda a galera que ta começando com Ruby!

Deixe uma resposta

O seu endereço de email não será publicado Campos obrigatórios são marcados *

*

Você pode usar estas tags e atributos de HTML: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>