├── assets ├── logo.png ├── inserindo-dados │ ├── erro-1.png │ ├── erro-2.png │ ├── erro-3.png │ ├── output-1.png │ └── output-2.png ├── deletando-dados │ ├── output-1.png │ └── output-2.png ├── editando-dados │ ├── output-1.png │ └── output-2.png ├── listando-dados │ └── output-1.png ├── validacao-dados │ └── output-2.png ├── hello-world │ └── hello-world-1.png ├── adicionando-comentarios │ └── output-1.png ├── deletando-comentarios │ └── output-1.png └── instalacao-rails-windows │ ├── nodejs-1.png │ ├── sqlite-1.png │ ├── download-ruby-windows-1.png │ ├── download-ruby-windows-2.png │ ├── download-ruby-windows-3.png │ ├── download-ruby-windows-4.png │ ├── download-ruby-windows-5.png │ ├── download-ruby-windows-6.png │ └── download-ruby-windows-7.png ├── contents ├── criar-projeto │ └── README.md ├── instalacao-linux │ └── README.md ├── criando-resources │ └── README.md ├── duplicacao │ └── README.md ├── estrutura-pastas │ └── README.md ├── hello-world │ └── README.md ├── deletando-comentarios │ └── README.md ├── duplicacao2 │ └── README.md ├── deletando-dados │ └── README.md ├── listando-dados │ └── README.md ├── validacao-dados │ └── README.md ├── editando-dados │ └── README.md ├── adicionando-comentarios │ └── README.md ├── instalacao-windows │ └── README.md └── inserindo-dados │ └── README.md ├── LICENSE └── README.md /assets/logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/rails4noobs/HEAD/assets/logo.png -------------------------------------------------------------------------------- /assets/inserindo-dados/erro-1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/rails4noobs/HEAD/assets/inserindo-dados/erro-1.png -------------------------------------------------------------------------------- /assets/inserindo-dados/erro-2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/rails4noobs/HEAD/assets/inserindo-dados/erro-2.png -------------------------------------------------------------------------------- /assets/inserindo-dados/erro-3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/rails4noobs/HEAD/assets/inserindo-dados/erro-3.png -------------------------------------------------------------------------------- /assets/deletando-dados/output-1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/rails4noobs/HEAD/assets/deletando-dados/output-1.png -------------------------------------------------------------------------------- /assets/deletando-dados/output-2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/rails4noobs/HEAD/assets/deletando-dados/output-2.png -------------------------------------------------------------------------------- /assets/editando-dados/output-1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/rails4noobs/HEAD/assets/editando-dados/output-1.png -------------------------------------------------------------------------------- /assets/editando-dados/output-2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/rails4noobs/HEAD/assets/editando-dados/output-2.png -------------------------------------------------------------------------------- /assets/inserindo-dados/output-1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/rails4noobs/HEAD/assets/inserindo-dados/output-1.png -------------------------------------------------------------------------------- /assets/inserindo-dados/output-2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/rails4noobs/HEAD/assets/inserindo-dados/output-2.png -------------------------------------------------------------------------------- /assets/listando-dados/output-1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/rails4noobs/HEAD/assets/listando-dados/output-1.png -------------------------------------------------------------------------------- /assets/validacao-dados/output-2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/rails4noobs/HEAD/assets/validacao-dados/output-2.png -------------------------------------------------------------------------------- /assets/hello-world/hello-world-1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/rails4noobs/HEAD/assets/hello-world/hello-world-1.png -------------------------------------------------------------------------------- /assets/adicionando-comentarios/output-1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/rails4noobs/HEAD/assets/adicionando-comentarios/output-1.png -------------------------------------------------------------------------------- /assets/deletando-comentarios/output-1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/rails4noobs/HEAD/assets/deletando-comentarios/output-1.png -------------------------------------------------------------------------------- /assets/instalacao-rails-windows/nodejs-1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/rails4noobs/HEAD/assets/instalacao-rails-windows/nodejs-1.png -------------------------------------------------------------------------------- /assets/instalacao-rails-windows/sqlite-1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/rails4noobs/HEAD/assets/instalacao-rails-windows/sqlite-1.png -------------------------------------------------------------------------------- /assets/instalacao-rails-windows/download-ruby-windows-1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/rails4noobs/HEAD/assets/instalacao-rails-windows/download-ruby-windows-1.png -------------------------------------------------------------------------------- /assets/instalacao-rails-windows/download-ruby-windows-2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/rails4noobs/HEAD/assets/instalacao-rails-windows/download-ruby-windows-2.png -------------------------------------------------------------------------------- /assets/instalacao-rails-windows/download-ruby-windows-3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/rails4noobs/HEAD/assets/instalacao-rails-windows/download-ruby-windows-3.png -------------------------------------------------------------------------------- /assets/instalacao-rails-windows/download-ruby-windows-4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/rails4noobs/HEAD/assets/instalacao-rails-windows/download-ruby-windows-4.png -------------------------------------------------------------------------------- /assets/instalacao-rails-windows/download-ruby-windows-5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/rails4noobs/HEAD/assets/instalacao-rails-windows/download-ruby-windows-5.png -------------------------------------------------------------------------------- /assets/instalacao-rails-windows/download-ruby-windows-6.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/rails4noobs/HEAD/assets/instalacao-rails-windows/download-ruby-windows-6.png -------------------------------------------------------------------------------- /assets/instalacao-rails-windows/download-ruby-windows-7.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/rails4noobs/HEAD/assets/instalacao-rails-windows/download-ruby-windows-7.png -------------------------------------------------------------------------------- /contents/criar-projeto/README.md: -------------------------------------------------------------------------------- 1 | # Criando Projeto em Rails 2 | 3 | Para criar um projeto padrão com Rails é bem simples, iremos criar um projeto padrão do Rails, usando o SQLite como banco de dados, que é o padrão do Rails, iremos dar o nome desse projeto de blog, pois este site o usuário poderá criar artigos, editar artigos, comentar artigos e deletar um comentário de um artigo, para isso, abre seu terminal ou prompt de comando, acesse a pasta que deseja guardar o projeto (como ``Documentos``) e use o comando: 4 | 5 | ``rails new blog`` 6 | 7 | rails se refere ao próprio rails, new serve para criarmos um novo projeto e blog é o nome do projeto, que também será o nome da pasta. 8 | 9 | agora entre na pasta com ``cd blog``, agora dentro da pasta, digite: 10 | 11 | ``rails server`` 12 | 13 | Pronto! a sua aplicação Rails já está funcionando, entre em [localhost:3000](http://localhost:3000) e veja uma mensagem padrão do Rails, isso significa que o seu ambiente de desenvolvimento está funcionando corretamente! 14 | 15 | ## Proximo => 16 | 17 | [Estrutura de pastas do Rails](../estrutura-pastas/README.md) -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2020 Lissa Ferreira 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /contents/instalacao-linux/README.md: -------------------------------------------------------------------------------- 1 | # Instalando Ruby on Rails no Linux 2 | 3 | Instalar o Ruby on Rails no Linux é bem simples, use o terminal para instalar o Ruby usando o seu gerenciador de pacotes. 4 | 5 | Também teremos que instalar além do Ruby, o Node, Yarn e SQLite, o Node e o Yarn envolvem o Javascript que será usado pelo Rails, você não precisa saber de Javascript para programar em Rails, e o SQLite será o banco de dados local que será usado por padrão pelo Rails, mas você pode usar qualquer um depois que aprender Rails, como MySQL e PostgreSQL 6 | 7 | # Debian, Ubuntu, Linux Mint e Derivados 8 | 9 | para instalar o Ruby e o Ruby Gems faça: 10 | 11 | ``sudo apt install ruby sqlite3 yarn nodejs`` 12 | 13 | # Fedora 14 | 15 | faça: 16 | 17 | ``sudo dnf install ruby sqlite3 yarn nodejs`` 18 | 19 | # Arch 20 | 21 | faça: 22 | 23 | ``sudo pacman -Syu ruby sqlite3 yarn nodejs`` 24 | 25 | # Gentoo 26 | 27 | faça: 28 | 29 | ``sudo emerge dev-lang/ruby dev-db/sqlite nodejs sys-apps/yarn`` 30 | 31 | # Rails 32 | 33 | Para instalar o Ruby on Rails em seu sistema, use o Gems para isso: 34 | 35 | ``gem install rails`` 36 | 37 | E pronto! teste se o rails foi corretamente instalado com: 38 | 39 | ``rails -v`` 40 | 41 | Caso apareça a versão instalada do Rails, está tudo funcionando corretamente. 42 | 43 | ## Proximo => 44 | 45 | [Criar Projeto em Rails](../criar-projeto/README.md) 46 | -------------------------------------------------------------------------------- /contents/criando-resources/README.md: -------------------------------------------------------------------------------- 1 | # Criando Resources 2 | 3 | Uma *resource* é o conjunto de objetos parecidos, com ela, poderemos criar um *Controller* e fazer CRUD neste *Controller*, assim poderemos criar, remover, editar,etc items do nosso banco de dados. 4 | 5 | Para criarmos uma resource é bem simples, abra ``config/routes.tb`` e digite: 6 | 7 | ```ruby 8 | Rails.application.routes.draw do 9 | get 'welcome/index' 10 | 11 | resources :artigos 12 | 13 | root 'welcome#index' 14 | end 15 | ``` 16 | 17 | Agora execute o comando ``rails routes`` para ver as rotas do *resource* que você acabou de criar, de criação, remoção, edição,etc. Você verá algo parecido com isso: 18 | 19 | `` 20 | Prefix Verb URI Pattern Controller#Action 21 | welcome_index GET /welcome/index(.:format) welcome#index 22 | artigos GET /artigos(.:format) artigos#index 23 | POST /artigos(.:format) artigos#create 24 | new_artigo GET /artigos/new(.:format) artigos#new 25 | edit_artigo GET /artigos/:id/edit(.:format) artigos#edit 26 | artigo GET /artigos/:id(.:format) artigos#show 27 | PATCH /artigos/:id(.:format) artigos#update 28 | PUT /artigos/:id(.:format) artigos#update 29 | DELETE /artigos/:id(.:format) artigos#destroy 30 | root GET / welcome#index 31 | `` 32 | 33 | Pronto! Criamos uma nova *Resource*, dessa maneira que poderemos fazer CRUD dos dados. 34 | 35 | ## Proximo => 36 | 37 | [Inserindo Dados](../inserindo-dados/README.md) -------------------------------------------------------------------------------- /contents/duplicacao/README.md: -------------------------------------------------------------------------------- 1 | # Removendo Duplicação em Arquivos 2 | 3 | Nas etapas anteriores, criamos um formulário de criação e outro de edição, mas os dois são iguais, como podemos tirar essa duplicação no código e deixar apenas um único formulário que será ultilizado pelos dois? 4 | 5 | Crie o arquivo ``apps/views/artigos/_form.html.erb`` e coloque o conteúdo do formulário de edição, dessa maneira: 6 | 7 | ```ruby 8 | <%= form_with(model: @artigo, local: true) do |form| %> 9 | 10 | <% if @artigo.errors.any? %> 11 |
12 |

13 | <%= pluralize(@artigo.errors.count, "error") %> Probido de ser salvo este artigo pois: 14 |

15 | 20 |
21 | <% end %> 22 | 23 |

24 | <%= form.label :titulo %>
25 | <%= form.text_field :titulo %> 26 |

27 | 28 |

29 | <%= form.label :texto %>
30 | <%= form.text_area :texto %> 31 |

32 | 33 |

34 | <%= form.submit %> 35 |

36 | 37 | <% end %> 38 | ``` 39 | 40 | Como este formulário é um componente que será re-ultilizado, use o _ antes do nome. 41 | 42 | Agora abra os dois arquivos, a view de criação e a view de edição e substitua todo o conteúdo do formulário, por ``<%= render 'form' %>``, dessa maneira: 43 | 44 | view da criação: 45 | 46 | ```ruby 47 | <%= render 'form' %> 48 | 49 | <%= link_to 'Voltar', artigos_path %> 50 | ``` 51 | 52 | view de edição: 53 | 54 | ```ruby 55 |

Editar artigo

56 | 57 | <%= render 'form' %> 58 | 59 | <%= link_to 'Voltar', artigos_path %> 60 | ``` 61 | 62 | Pronto! modficamos e agora, a quantidade de código diminuiu, a repetição também, e a simplicidade aumentou, facilidade de escalar o código. 63 | 64 | ## Proximo => 65 | 66 | [Deletando Artigos](../deletando-dados/README.md) -------------------------------------------------------------------------------- /contents/estrutura-pastas/README.md: -------------------------------------------------------------------------------- 1 | # Estrutura de pastas do Rails 2 | 3 | Você viu que dentro do blog (pasta) há muitas pastas e arquivos, mas, o que significam essas pastas e arquivos? 4 | 5 | Cada uma dessas pastas e arquivos tem uma função específica, como configurações, interfaces,etc. Para isso, temos esta tabela abaixo que explica a função de cada pasta e arquivo que o Rails cria por padrão: 6 | 7 | | Arquivo/Pasta | Função | 8 | |:--------------|-------:| 9 | |app/ |Armazena os controllers, models, views, helpers, mailers, channels, jobs e assets da sua aplicação, a maior parte do trabalho e arquivos da sua aplicação estaram aqui. 10 | |bin/ | Armazena os scripts Rails da sua aplicação, como o server, para iniciar o servidor 11 | |config/ | Configura as rotas, bancos de dados e mais da sua aplicação 12 | |config.ru | Configuração do Rack 13 | |db/ | Armazena o schema do banco de dados e as migrations, no nosso caso, o SQLite estará aqui. 14 | | Gemfile e Gemfile.lock | Determinam as dependências que são necessárias na nossa aplicação Rails 15 | | lib/ | Módulos (bibliotecas) da nossa aplicação 16 | | log/ | Arquivos de log 17 | | packeage.json | Determina quais dependências do Node serão usadas 18 | | public/ | Arquivos compilados e assets compilados 19 | | Rakefile | Localiza e determina as tarefas que podem ser feitas pelo Rake 20 | | README.md | Arquivo que descreve o que aquela aplicação faz ou serve 21 | | storage/ | Active Storage para o Disk Service 22 | | test/ | diretório para testes 23 | | tmp/ | arquivos temporários, como cache 24 | | vendor/ | Armazena todo o código de terceiros 25 | | .gitignore | Arquivos que serão ignorados pelo git 26 | | .ruby-version | Armazena a versão do Ruby usada no projeto 27 | 28 | A maioria dessas pastas e arquivos não serão usadas neste 4noobs, a lista cita TODAS por efeitos de conhecimento, você não precisa decorar, pois você irá aos poucos entender melhor a função de algumas pastas e arquivos citados acima. 29 | 30 | ## Proximo => 31 | 32 | [Hello World no Rails](../hello-world/README.md) 33 | -------------------------------------------------------------------------------- /contents/hello-world/README.md: -------------------------------------------------------------------------------- 1 | # Hello World em Rails 2 | 3 | Para criarmos uma página em nosso projeto, com um texto "Hello World!" na tela, precisaremos criar uma *route*, que será o caminho para chegar na página com o texto, e uma *view*, que é o conteúdo da página, no Rails, usamos HTML junto com o Rails, podendo colocar partes do HTML que será completada pelo Rails, você entenderá isso mais adiante, agora, você apenas usará o HTML. 4 | 5 | Primeiro precisamos criar um *Controller*, que receberá requisições específicas, enquanto a rota controlará qual controller vai receber a requisição, em Rails, podemos criar o controller ``Welcome`` com o seguinte comando: 6 | 7 | ``rails generate controller Welcome index`` 8 | 9 | A *view* irá mostrar o conteúdo de uma maneira que seja legível para humanos, como o HTML que irá se transformar em uma página web, enquanto o *controller* captura a informação, a *view* apenas mostrará ela ao usuário. 10 | 11 | Agora abra o arquivo ``app/views/welcome/index.html.erb`` delete todo o código que estava escrito e coloque o conteúdo: 12 | 13 | ````html 14 |

Hello, World!

15 | ```` 16 | 17 | Lembrando, não copie e cole o código, escreva ele, isso é importante para seu aprendizado. 18 | 19 | A página ainda não pode ser aberta, pois ainda não definimos ela nas rotas, para adicionar essa página nas rotas, abra ``config/routes.rb`` e escreva: 20 | 21 | ````ruby 22 | Rails.application.routes.draw do 23 | get 'welcome/index' 24 | 25 | root 'welcome#index' 26 | end 27 | ```` 28 | 29 | no código acima, estamos usando o ``get`` para pegar o ``welcome`` que é o nosso controller, e o ``root`` está definindo que o index do welcome (a view que acabamos de criar) será a página inicial da nossa aplicação. 30 | 31 | Lembrando que o ``get`` você não precisou escrever, pois ele foi colocado aqui pelo própio ruby, quando executamos ``rails generate controller Welcome index`` 32 | 33 | Pronto, agora temos nossa página de Hello World pronta! 34 | 35 | ![Hello, World!](../../assets/hello-world/hello-world-1.png) 36 | 37 | ## Proximo => 38 | 39 | [Criando Resources](../criando-resources) 40 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Rails4noobs 2 | 3 | Ruby on Rails é um framework Ruby feito para usar o Ruby no backend de um serviço web, como um PHP ou Node, mas, o que ele tem de diferente em relação á sua concorrência? 4 | 5 | Rails tem como vantagens: 6 | 7 | - Facilidade no desenvolvimento 8 | - Rapidez na resposta do servidor 9 | - Velocidade no desenvolvimento 10 | - Código simples e curto 11 | - Mercado ainda ativo 12 | 13 | Por isso que neste 4noobs, iremos aprender sobre Ruby on Rails, ou simplesmente Rails! 14 | 15 | ![Logo](assets/logo.png) 16 | 17 | ## Pré Requisitos 18 | 19 | 1. Saiba o básico sobre Ruby, caso não saiba, aprenda no [ruby4noobs](https://github.com/lissatransborda/ruby4noobs) 20 | 2. Saiba o básico de HTML5 21 | 3. [Instalação do Ruby on Rails no Windows](contents/instalacao-windows/README.md) 22 | 4. [Instalação do Ruby on Rails no Linux](contents/instalacao-linux/README.md) 23 | 24 | ## Começo Rápido 25 | 26 | 1. [Criar um projeto com Rails](contents/criar-projeto/README.md) 27 | 2. [Estrutura de Pastas](contents/estrutura-pastas/README.md) 28 | 3. [Hello World](contents/hello-world/README.md) 29 | 4. [Criando Resources](contents/criando-resources/README.md) 30 | 5. [Inserindo Artigos](contents/inserindo-dados/README.md) 31 | 6. [Listando Artigos](contents/listando-dados/README.md) 32 | 7. [Validação de dados](contents/validacao-dados/README.md) 33 | 8. [Editando Artigos](contents/editando-dados/README.md) 34 | 9. [Removendo Duplicação no Código](contents/duplicacao/README.md) 35 | 10. [Deletando Artigos](contents/deletando-dados/README.md) 36 | 11. [Adicionando Comentários](contents/adicionando-comentarios/README.md) 37 | 12. [Removendo Duplicação no Código Novamente](contents/duplicacao2/README.md) 38 | 13. [Deletando Comentários](contents/deletando-comentarios/README.md) 39 | 40 | ---- 41 | 42 | # Contribuição 43 | 44 | Caso queria adicionar qualquer tópico, conceito, conteúdo ou até mesmo corrigir um erro ortográfico, crie uma Issue ou uma Pull Request, qualquer contribuição é importante! 45 | 46 | # Fontes 47 | 48 | Este 4noobs se baseia na [documentação oficial do Rails](https://guides.rubyonrails.org), usando como projeto prático o clássico Blog feito em Rails! 49 | -------------------------------------------------------------------------------- /contents/deletando-comentarios/README.md: -------------------------------------------------------------------------------- 1 | # Deletando Comentários 2 | 3 | Agora vamos colocar a última feature do nosso site, a opção de deletar comentários. 4 | 5 | Edite o arquivo ``app/views/comentarios/_comentario.html.erb`` e escreva o link de delete do comentário: 6 | 7 | ```ruby 8 |

9 | Comentarista: 10 | <%= comentario.comentarista %> 11 |

12 | 13 |

14 | Comentario: 15 | <%= comentario.corpo %> 16 |

17 | 18 |

19 | <%= link_to 'Deletar Comentário', [comentario.artigo, comentario], 20 | method: :delete, 21 | data: { confirm: 'Você tem Certeza?' } %> 22 |

23 | ``` 24 | 25 | Agora vamos no *controller* de comentários e escreva a função de destroy: 26 | 27 | ```ruby 28 | class ComentariosController < ApplicationController 29 | def create 30 | @artigo = Artigo.find(params[:artigo_id]) 31 | @comment = @artigo.comentarios.create(comentario_params) 32 | redirect_to artigo_path(@artigo) 33 | end 34 | 35 | def destroy 36 | @artigo = Artigo.find(params[:artigo_id]) 37 | @comentario = @artigo.comentarios.find(params[:id]) 38 | @comentario.destroy 39 | redirect_to artigo_path(@artigo) 40 | end 41 | 42 | private 43 | def comentario_params 44 | params.require(:comentario).permit(:comentarista, :corpo) 45 | end 46 | end 47 | ``` 48 | 49 | Agora vamos ao *model* de artigos ``app/models/artigo.rb`` e vamos definir que se um artigo for deletado, todos os dependentes, que no caso são os comentários, também serão deletados, da seguinte maneira: 50 | 51 | ```ruby 52 | class Artigo < ApplicationRecord 53 | has_many :comentarios, dependent: :destroy 54 | validates :titulo, presence: true, 55 | length: { minimum: 5 } 56 | end 57 | 58 | ``` 59 | 60 | ``dependent: :destroy`` avisa ao Rails que se caso algum item deste model for deletado, todos os items que tem como referencia este item do model que está sendo deletado, serão deletados, que no caso, se um artigo for deletado, todos os comentários dele também serão. 61 | 62 | Pronto!, agora temos o botão para deletar um comentário, e se caso deletarmos um artigo, todos os seus comentários também serão deletados! 63 | 64 | ![Output 1](../../assets/deletando-comentarios/output-1.png) -------------------------------------------------------------------------------- /contents/duplicacao2/README.md: -------------------------------------------------------------------------------- 1 | # Removendo Duplicação de Código Novamente 2 | 3 | Agora temos dois formulários na nossa aplicação, o formulário de criação do artigo e o formulário de criação de um novo comentário, agora vamos separar o formulário de criação de um novo comentário á um arquivo externo, pois assim, nossa aplicação ficará mais organizada e com um código mais simples. 4 | 5 | Crie o arquivo ``apps/views/comentarios/_form.html.erb`` e escreva: 6 | 7 | ```ruby 8 | <%= form_with(model: [ @artigo, @artigo.comentarios.build ], local: true) do |form| %> 9 |

10 | <%= form.label :comentarista %>
11 | <%= form.text_field :comentarista %> 12 |

13 |

14 | <%= form.label :corpo %>
15 | <%= form.text_area :corpo %> 16 |

17 |

18 | <%= form.submit %> 19 |

20 | <% end %> 21 | ``` 22 | 23 | Lembrando que este é o mesmo conteúdo do formulário de comentários da view show do artigos. 24 | 25 | Agora edite o arquivo ``app/views/comentarios/_comentario.html.erb`` e coloque o conteúdo: 26 | 27 | ```ruby 28 | <% @artigo.comentarios.each do |comentario| %> 29 |

30 | Comentarista: 31 | <%= comentario.comentarista %> 32 |

33 | 34 |

35 | Comentario: 36 | <%= comentario.corpo %> 37 |

38 | <% end %> 39 | ``` 40 | 41 | Agora edite o arquivo ``app/views/artigos/show.html.erb`` e substitua o form de comentários por um render. 42 | 43 | ```ruby 44 |

45 | Título: 46 | <%= @artigo.titulo %> 47 |

48 | 49 |

50 | Texto: 51 | <%= @artigo.texto %> 52 |

53 | 54 | <%= render @artigo.comentarios %> 55 | 56 |

Adicionar um comentário:

57 | 58 | <%= render 'comentarios/form' %> 59 | 60 | <%= link_to "Voltar", artigos_path %> 61 | ``` 62 | 63 | Quando nós temos uma associação como essa, um artigo que tem vários comentários, mas um comentário só pode ter um artigo, e criamos uma view que no caso, está dentro dos comentários e se chama ``_comentario.rb`` na hora de renderizarmos, podemos usar ``@artigo.comentarios``, de maneira mais simples e usual. 64 | 65 | Pronto! separamos o formulário de comentários em um arquivo separado e o arquivo que mostra os comentários em um outro arquivo. 66 | 67 | ## Proximo => 68 | 69 | [Deletando Comentários](contents/deletando-comentarios/README.md) -------------------------------------------------------------------------------- /contents/deletando-dados/README.md: -------------------------------------------------------------------------------- 1 | # Deletando Dados 2 | 3 | Agora vamos colocar uma nova funcionalidade, a possibilidade de deletar artigos, ao lado do botão de ver e editar, vamos criar essa função no *controller* de artigos, em ``app/controllers/artigos_controller.rb``: 4 | 5 | ```ruby 6 | class ArtigosController < ApplicationController 7 | def index 8 | @artigos = Artigo.all 9 | end 10 | 11 | def show 12 | @artigo = Artigo.find(params[:id]) 13 | end 14 | 15 | def new 16 | @artigo = Artigo.new 17 | end 18 | 19 | def edit 20 | @artigo = Artigo.find(params[:id]) 21 | end 22 | 23 | def update 24 | @artigo = Artigo.find(params[:id]) 25 | 26 | if @artigo.update(artigo_params) 27 | redirect_to @artigo 28 | else 29 | render 'edit' 30 | end 31 | end 32 | 33 | def create 34 | @artigo = Artigo.new(artigo_params) 35 | 36 | if @artigo.save 37 | redirect_to @artigo 38 | else 39 | render 'new' 40 | end 41 | end 42 | 43 | def destroy 44 | @artigo = Artigo.find(params[:id]) 45 | @artigo.destroy 46 | 47 | redirect_to artigos_path 48 | end 49 | 50 | private 51 | def artigo_params 52 | params.require(:artigo).permit(:titulo, :texto) 53 | end 54 | end 55 | ``` 56 | 57 | O arquivo está o mesmo, mas adicionamos a função destroy, que irá buscar o artigo com a ID específica, deletar ele e voltar para a lista que mostra todos os artigos. 58 | 59 | Agora vamos voltar ao index, vamos adicionar um link (botão) para deletar algum artigo, em ``app/views/artigos/index.html.erb``: 60 | 61 | ```ruby 62 |

Listando Artigos

63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | <% @artigos.each do |artigo| %> 72 | 73 | 74 | 75 | 76 | 77 | 80 | 81 | <% end %> 82 |
TítuloTexto
<%= artigo.titulo %><%= artigo.texto %><%= link_to 'Ver', artigo_path(artigo) %><%= link_to 'Editar', edit_artigo_path(artigo) %><%= link_to 'Deletar', artigo_path(artigo), 78 | method: :delete, 79 | data: { confirm: 'Tem Certeza?' } %>
83 | ``` 84 | 85 | Como podemos ver, o arquivo continua igual, mas temos um link, que leva ao artigo em questão, usando o método delete, com uma confirmação na tela de "Tem Certeza?", veja: 86 | 87 | ![Output 1](../../assets/deletando-dados/output-1.png) 88 | 89 | ![Output 2](../../assets/deletando-dados/output-2.png) 90 | 91 | Caso clique em "Ok" o artigo será deletado. 92 | 93 | ## Proximo => 94 | 95 | [Adicionando Comentários](../adicionando-comentarios/README.md) -------------------------------------------------------------------------------- /contents/listando-dados/README.md: -------------------------------------------------------------------------------- 1 | # Listando Dados 2 | 3 | Já conseguimos criar o artigo e visualizar ele de maneira individual, agora precisamos listar todos os artigos, para isso, dentro do *Controller* do Artigo, iremos criar um método chamado index, que irá listar TODOS os artigos existentes. 4 | 5 | Abra o arquivo ``apps/controler/artigos_controller.rb`` e escreva a função index: 6 | 7 | ```ruby 8 | class ArtigosController < ApplicationController 9 | def index 10 | @artigos = Artigo.all 11 | end 12 | 13 | def show 14 | @artigo = Artigo.find(params[:id]) 15 | end 16 | 17 | def new 18 | end 19 | 20 | def create 21 | @artigo = Artigo.new(artigo_params) 22 | 23 | @artigo.save 24 | redirect_to @artigo 25 | end 26 | 27 | private 28 | def artigo_params 29 | params.require(:artigo).permit(:titulo, :texto) 30 | end 31 | end 32 | ``` 33 | 34 | Agora vamos criar a view index em ``apps/views/artigos/index.html.erb`` para mostrar os artigos: 35 | 36 | ```ruby 37 |

Listando Artigos

38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | <% @artigos.each do |artigo| %> 47 | 48 | 49 | 50 | 51 | 52 | <% end %> 53 |
TítuloTexto
<%= artigo.titulo %><%= artigo.texto %><%= link_to 'Ver', artigo_path(artigo) %>
54 | ``` 55 | 56 | Pronto! Agora todos os artigos podem ser vistos, tente criar um novo artigo e ele aparecerá na lista. 57 | 58 | ![Output 1](../../assets/listando-dados/output-1.png) 59 | 60 | 61 | ## Adicionando Links 62 | 63 | Agora entre na view da função new e adicione um link para voltar á página inicial abaixo do formulário: 64 | 65 | ```ruby 66 | <%= form_with scope: :artigo, url: artigos_path, local: true do |form| %> 67 |

68 | <%= form.label :titulo %>
69 | <%= form.text_field :titulo %> 70 |

71 | 72 |

73 | <%= form.label :texto %>
74 | <%= form.text_area :texto %> 75 |

76 | 77 |

78 | <%= form.submit %> 79 |

80 | <% end %> 81 | 82 | <%= link_to "Voltar", artigos_path %> 83 | ``` 84 | 85 | Agora abra a view da função show e faça a mesma coisa: 86 | 87 | ```ruby 88 |

89 | Título: 90 | <%= @artigo.titulo %> 91 |

92 | 93 |

94 | Texto: 95 | <%= @artigo.texto %> 96 |

97 | 98 | <%= link_to "Voltar", artigos_path %> 99 | ``` 100 | 101 | O que acabamos de fazer foi criar links que ajudarão o usuário a navegar entre as páginas. 102 | 103 | ## Proximo => 104 | 105 | [Validação de dados](../validacao-dados/README.md) -------------------------------------------------------------------------------- /contents/validacao-dados/README.md: -------------------------------------------------------------------------------- 1 | # Validando Dados 2 | 3 | Agora vamos colocar uma camada de segurança, vamos validar o título e obrigar que ele tenha no mínimo 5 caracteres, podemos fazer isso facilmente em Rails, edite o *model* do artigo em ``apps/models/artigo.rb`` e escreva: 4 | 5 | ```ruby 6 | class Artigo < ApplicationRecord 7 | validates :titulo, presence: true, 8 | length: { minimum: 5 } 9 | end 10 | ``` 11 | 12 | No caso, a validação está no título, onde determinados que ele deve aparecer, e que seu tamanho mínimo é 5. 13 | 14 | Agora, quando executarmos ``@artigo.save`` e o título não for válido, retornará falso, então podemos mudar no nosso *Controller*, e mandar o usuário novamente ao formulário caso o título não seja válido dessa maneira: 15 | 16 | ```ruby 17 | class ArtigosController < ApplicationController 18 | def index 19 | @artigos = Artigo.all 20 | end 21 | 22 | def show 23 | @artigo = Artigo.find(params[:id]) 24 | end 25 | 26 | def new 27 | @artigo = Artigo.new 28 | end 29 | 30 | def create 31 | @artigo = Artigo.new(artigo_params) 32 | 33 | if @artigo.save 34 | redirect_to @artigo 35 | else 36 | render 'new' 37 | end 38 | end 39 | 40 | private 41 | def artigo_params 42 | params.require(:artigo).permit(:titulo, :texto) 43 | end 44 | end 45 | ``` 46 | 47 | O código acima está normal, execeto que na função new, é criado o Artigo de maneira padrão, pois se não fizessemos isso, daria erro toda vez que entrassemos no artigo/new, e também, se ``@artigo.save`` ser falso, o usuário será movido ao new, que é a rota de criação do formulário. 48 | 49 | Agora vamos abrir ``apps/views/artigos/new.html.erb`` e vamos colocar uma verificação de erros, caso existam erros, eles serão mostrados, que no caso, seria o título ser pequeno demais. 50 | 51 | ```ruby 52 | <%= form_with scope: :artigo, url: artigos_path, local: true do |form| %> 53 | 54 | <% if @artigo.errors.any? %> 55 |
56 |

57 | <%= pluralize(@artigo.errors.count, "error") %> Proibido de ser salvo este artigo: 58 |

59 | 64 |
65 | <% end %> 66 | 67 |

68 | <%= form.label :titulo %>
69 | <%= form.text_field :titulo %> 70 |

71 | 72 |

73 | <%= form.label :texto %>
74 | <%= form.text_area :texto %> 75 |

76 | 77 |

78 | <%= form.submit %> 79 |

80 | 81 | <% end %> 82 | 83 | <%= link_to 'Voltar', artigos_path %> 84 | ``` 85 | 86 | Pronto!, tente criar um artigo com o título com menos de 5 caracteres agora: 87 | 88 | ![Output 2](../../assets/validacao-dados/output-2.png) 89 | 90 | ## Proximo => 91 | 92 | [Editando Artigos](../editando-dados/README.md) -------------------------------------------------------------------------------- /contents/editando-dados/README.md: -------------------------------------------------------------------------------- 1 | # Editando Dados 2 | 3 | Agora vamos adicionar uma nova função no nosso blog de artigos, vamos dar a opção do usuário editar um artigo, primeiramente vamos criar no nosso *Controller* a função edit, que possibilitará que a rota artigos/edit funcione e que a view seja possível de ser visualizada. 4 | 5 | ```ruby 6 | class ArtigosController < ApplicationController 7 | def index 8 | @artigos = Artigo.all 9 | end 10 | 11 | def show 12 | @artigo = Artigo.find(params[:id]) 13 | end 14 | 15 | def new 16 | @artigo = Artigo.new 17 | end 18 | 19 | def edit 20 | @artigo = Artigo.find(params[:id]) 21 | end 22 | 23 | def update 24 | @artigo = Artigo.find(params[:id]) 25 | 26 | if @artigo.update(artigo_params) 27 | redirect_to @artigo 28 | else 29 | render 'edit' 30 | end 31 | end 32 | 33 | def create 34 | @artigo = Artigo.new(artigo_params) 35 | 36 | if @artigo.save 37 | redirect_to @artigo 38 | else 39 | render 'new' 40 | end 41 | end 42 | 43 | private 44 | def artigo_params 45 | params.require(:artigo).permit(:titulo, :texto) 46 | end 47 | end 48 | ``` 49 | 50 | O *controller* continua igual, mas tem uma função chamada edit, e uma outra chamada update, a edit criará a rota artigos/edit, e a update irá buscar o artigo com a ID específica, e esse artigo será mandado para a view, é por isso que na view podemos usar os dados específicos de um ou mais artigos, tudo depende do que está sendo feito dentro do *controller*. 51 | 52 | Crie agora o arquivo ``app/views/artigos/edit.html.erb`` com um conteúdo muito parecido com o da view new, mas com as opções necessárias para a edição, escreva com o conteúdo abaixo: 53 | 54 | ```ruby 55 |

Editar artigo

56 | 57 | <%= form_with(model: @artigo, local: true) do |form| %> 58 | 59 | <% if @artigo.errors.any? %> 60 |
61 |

62 | <%= pluralize(@artigo.errors.count, "error") %> Probido de ser salvo este artigo pois: 63 |

64 | 69 |
70 | <% end %> 71 | 72 |

73 | <%= form.label :titulo %>
74 | <%= form.text_field :titulo %> 75 |

76 | 77 |

78 | <%= form.label :texto %>
79 | <%= form.text_area :texto %> 80 |

81 | 82 |

83 | <%= form.submit %> 84 |

85 | 86 | <% end %> 87 | 88 | <%= link_to 'Voltar', artigos_path %> 89 | ``` 90 | 91 | Como podemos ver, o model está setado para @artigo, que é a variável que guarda os dados do artigo em questão. 92 | 93 | Agora vamos mudar o index, e adicionar um link que leva á edição dos artigos, assim cada artigo terá dois botões, um para ver (show) e outro para editar (edit), veja abaixo: 94 | 95 | ```ruby 96 |

Listando Artigos

97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | <% @artigos.each do |artigo| %> 106 | 107 | 108 | 109 | 110 | 111 | 112 | <% end %> 113 |
TítuloTexto
<%= artigo.titulo %><%= artigo.texto %><%= link_to 'Ver', artigo_path(artigo) %><%= link_to 'Editar', edit_artigo_path(artigo) %>
114 | ``` 115 | 116 | Como podemos ver, o link para editar o artigo é ``edit_artigo_path(artigo)`` 117 | 118 | E pronto!, agora podemos editar o artigo: 119 | 120 | ![Output 1](../../assets/editando-dados/output-1.png) 121 | 122 | Salvar e ver o artigo editado: 123 | 124 | ![Output 2](../../assets/editando-dados/output-2.png) 125 | 126 | 127 | ## Proximo => 128 | 129 | [Removendo Duplicação no código](../duplicacao/README.md) -------------------------------------------------------------------------------- /contents/adicionando-comentarios/README.md: -------------------------------------------------------------------------------- 1 | # Adicionando Comentários aos Artigos 2 | 3 | Agora vamos adicionar uma nova feature ao nosso site, a posssibilidade de adicionarmos comentários aos artigos. 4 | 5 | Primeiro vamos criar o *model* de comentários, o comentarista será quem comentou, corpo será o texto do comentário e o artigo será uma chave estrangeira que irá referenciar qual é o artigo que este comentário pertence, dessa maneira: 6 | 7 | ``rails generate model Comentario comentarista:string corpo:text artigo:references`` 8 | 9 | Agora vamos fazer a migration para criar efetivamente o *model*. 10 | 11 | ``rails db:migrate`` 12 | 13 | Agora apenas veja o arquivo ``apps/models/comentario.rb`` e você verá que este *model* comentário pertence ao *model* artigos, pois nós definimos na criação no *model*, usando: ``artigo:references``: 14 | 15 | ```ruby 16 | class Comentario < ApplicationRecord 17 | belongs_to :artigo 18 | end 19 | ``` 20 | 21 | Agora vamos associar os dois modelos, abra ``apps/models/artigos.rb`` e escreva: 22 | 23 | ```ruby 24 | class Artigo < ApplicationRecord 25 | has_many :comentarios 26 | validates :titulo, presence: true, 27 | length: { minimum: 5 } 28 | end 29 | ``` 30 | 31 | Pronto, agora definimos que todo artigo tem vários comentários. 32 | 33 | Agora vamos gerar uma rota, que será utilizada pelo Rails para saber onde os comentários estão: 34 | 35 | ```ruby 36 | Rails.application.routes.draw do 37 | get 'welcome/index' 38 | 39 | resources :artigos do 40 | resources :comentarios 41 | end 42 | 43 | root 'welcome#index' 44 | end 45 | ``` 46 | 47 | Agora vamos criar o *controller* dos comentários, assim poderemos manipular eles: 48 | 49 | `` 50 | rails generate controller Comentarios 51 | `` 52 | 53 | Agora vamos editar a view show em ``app/views/artigos/show.html.erb`` para o usuário poder ver os comentários: 54 | 55 | ```ruby 56 |

57 | Título: 58 | <%= @artigo.titulo %> 59 |

60 | 61 |

62 | Texto: 63 | <%= @artigo.texto %> 64 |

65 | 66 |

Adicionar um comentário:

67 | <%= form_with(model: [ @artigo, @artigo.comentarios.build ], local: true) do |form| %> 68 |

69 | <%= form.label :comentarista %>
70 | <%= form.text_field :comentarista %> 71 |

72 |

73 | <%= form.label :corpo %>
74 | <%= form.text_area :corpo %> 75 |

76 |

77 | <%= form.submit %> 78 |

79 | <% end %> 80 | 81 | <%= link_to "Voltar", artigos_path %> 82 | ``` 83 | 84 | Agora vamos editar o *controller* dos comentários em ``app/controllers/comentarios_controller.rb``, possibilitando a criação de um novo comentário em um artigo: 85 | 86 | ```ruby 87 | class ComentariosController < ApplicationController 88 | def create 89 | @artigo = Artigo.find(params[:artigo_id]) 90 | @comment = @artigo.comentarios.create(comentario_params) 91 | redirect_to artigo_path(@artigo) 92 | end 93 | 94 | private 95 | def comentario_params 96 | params.require(:comentario).permit(:comentarista, :corpo) 97 | end 98 | end 99 | ``` 100 | 101 | Agora vamos alterar a view show novamente para mostrarmos os comentários acima do formulário de criação de um: 102 | 103 | ```ruby 104 |

105 | Título: 106 | <%= @artigo.titulo %> 107 |

108 | 109 |

110 | Texto: 111 | <%= @artigo.texto %> 112 |

113 | 114 | <% @artigo.comentarios.each do |comentario| %> 115 |

116 | Comentarista: 117 | <%= comentario.comentarista %> 118 |

119 | 120 |

121 | Comentario: 122 | <%= comentario.corpo %> 123 |

124 | <% end %> 125 | 126 |

Adicionar um comentário:

127 | <%= form_with(model: [ @artigo, @artigo.comentarios.build ], local: true) do |form| %> 128 |

129 | <%= form.label :comentarista %>
130 | <%= form.text_field :comentarista %> 131 |

132 |

133 | <%= form.label :corpo %>
134 | <%= form.text_area :corpo %> 135 |

136 |

137 | <%= form.submit %> 138 |

139 | <% end %> 140 | 141 | <%= link_to "Voltar", artigos_path %> 142 | ``` 143 | 144 | Pronto! agora podemos ver e adicionar novos comentários: 145 | 146 | ![output 1](../../assets/adicionando-comentarios/output-1.png) 147 | 148 | ## Proximo => 149 | [Removendo Duplicação no Código Novamente](contents/duplicacao2/README.md) -------------------------------------------------------------------------------- /contents/instalacao-windows/README.md: -------------------------------------------------------------------------------- 1 | # Instalando Ruby on Rails no Windows 2 | 3 | Caso ainda não tenha baixado, baixe o Ruby no seu sistema: 4 | 5 | Acesse o site do [Ruby Installer](https://rubyinstaller.org/) 6 | 7 | ![Site do Ruby Installer](../../assets/instalacao-rails-windows/download-ruby-windows-1.png) 8 | 9 | Selecione a versão recomendada, que está marcada com um => antes do nome e versão 10 | 11 | ![Lista de versões](../../assets/instalacao-rails-windows/download-ruby-windows-2.png) 12 | 13 | Com o instalador baixado, clique duas vezes nele no Windows Explorer e comece a instalar como se fosse qualquer programa, aceitando os termos de uso por exemplo 14 | 15 | ![Instalação do Ruby Installer](../../assets/instalacao-rails-windows/download-ruby-windows-3.png) 16 | 17 | Garanta que os dois pacotes abaixo estão selecionados para serem instalados 18 | 19 | ![Seleção dos dois pacotes necessários](../../assets/instalacao-rails-windows/download-ruby-windows-4.png) 20 | 21 | Desmarque o checkbox "Run ridk install" to setup MSYS2 and development toolchain 22 | 23 | ![Desmarque o checkbox do ridk install](../../assets/instalacao-rails-windows/download-ruby-windows-5.png) 24 | 25 | Abra o prompt de comando ou preferencialmente o Powershell, e digite "ridk install", quando o comando ser executado aperte "3" para selecionar a terceira opção 26 | 27 | ![ridk install](../../assets/instalacao-rails-windows/download-ruby-windows-6.png) 28 | 29 | Quando o instalador perguntar "Which components shall be installed?" apenas digite ENTER e pronto, o Ruby está instalado na sua máquina! 30 | 31 | ![Final da instalação](../../assets/instalacao-rails-windows/download-ruby-windows-7.png) 32 | 33 | ## SQLite 34 | 35 | Sqlite será o banco de dados que iremos usar para armazenar os dados, para baixar o SQLite, entre no [site de download dele](https://www.sqlite.org/download.html) e procure os binários para Windows, que estão listados abaixo: 36 | 37 | ![Binários para windows](../../assets/instalacao-rails-windows/sqlite-1.png) 38 | 39 | Agora crie uma nova pasta, localizada em ``C:\sqlite``, isso signfica que você precisa acessar a pasta raiz do seu sistema (c:) e criar uma pasta chamada sqlite lá dentro, agora extraia o ZIP do sqlite dentro dessa pasta, agora navegue para dentro dessa pasta dessa forma: 40 | 41 | ``cd c:\sqlite`` 42 | 43 | e lá dentro, digite: 44 | 45 | ``sqlite3`` 46 | 47 | E pronto! o SQLite já está instalado, você pode digitar ``.quit`` para sair do prompt do SQLite. 48 | 49 | ## Nodejs 50 | 51 | O nodejs é uma maneira de rodar o Javascript na sua máquina, ele será usado pelo Rails, para instala-lo, entre na [Página de Download do Nodejs](https://nodejs.org/en/download/) e escolha o Windows Installer apertando em cima dele. 52 | 53 | ![Página de Download do Nodejs](../../assets/instalacao-rails-windows/nodejs-1.png) 54 | 55 | Depois de baixado, clique duas vezes no instalador e siga dando "Next" no wizard de instalação, por padrão você não precisa mudar nada. 56 | 57 | Depois disso, teste se o Node está instalado, para isso, faça: 58 | 59 | ``node -v`` 60 | 61 | Caso seja retornada a versão atual do Node, está funcionando corretamente. 62 | 63 | ## Yarn 64 | 65 | Yarn é uma das opções de gerenciador de pacotes do Node, ele também será usado exclusivamente pelo Rails 66 | 67 | Para baixar o yarn, [Clique neste link para baixar a última versão](https://yarnpkg.com/latest.msi) 68 | 69 | Depois disso, execute o wizard de instalação, Aceite os termos de uso e clique em "Next" até terminar a instalação. 70 | 71 | Para testar se o Yarn está instalado, faça: 72 | 73 | `` yarn --version`` 74 | 75 | Caso ele retorne a versão atual do yarn, tudo está correto. 76 | 77 | ## Gems 78 | 79 | Agora você precisa instalar o Ruby Gems, que é o gerenciador de pacotes do Ruby, você usará o Gems para instalar os pacotes (como bibliotecas) e o próprio Rails na sua máquina. 80 | 81 | Para baixar o Ruby Gems, entre no [site de download do Ruby Gems](https://rubygems.org/pages/download) e clique em ZIP, baixar ele em sua máquina, extraia-o, entre na pasta extraida do Ruby Gems usando o ``cd`` dessa maneira: 82 | 83 | ``cd Downloads\rubygems-[VERSÃO DO RUBYGEMS]`` 84 | 85 | e instale o Gems executando o ``setup.rb``, dessa maneira: 86 | 87 | ``ruby setup.rb`` 88 | 89 | agora para instalar o Rails em sua máquina é simples, apenas use o Gems para isso: 90 | 91 | ``gem install rails`` 92 | 93 | Pronto, agora para testar se o Rails foi instalado com sucesso, use: 94 | 95 | ``rails -v`` 96 | 97 | Caso apareça a versão atual do Rails, tudo está funcionando corretamente, e tods os pacotes e programas necessários foram instalados :smile: 98 | 99 | ## Proximo => 100 | 101 | [Criar Projeto em Rails](../criar-projeto/README.md) -------------------------------------------------------------------------------- /contents/inserindo-dados/README.md: -------------------------------------------------------------------------------- 1 | # Inserindo Dados 2 | 3 | Agora vamos fazer o "C" do CRUD, que é o create (criar), o que queremos fazer é uma página que peça ao usuário o título do artigo e o texto do artigo, é um exemplo bem simples e básico para compreendermos como funciona o Rails. 4 | 5 | Agora crie o *controller* de Artigos, da mesma forma que o Welcome, dessa maneira: 6 | 7 | ``rails generate controller Artigos`` 8 | 9 | Com isso, geramos o *Controller* Artigos, agora podemos adicionar, visualizar, editar e remover artigos. 10 | 11 | Agora abra o arquivo ``app/controllers/artigos_controllers.rb``, você vai ver isso aqui: 12 | 13 | ```ruby 14 | class ArtigosController < ApplicationController 15 | end 16 | ``` 17 | 18 | Como podemos ver, o *Controller* está vazio, ele não faz nada, será aqui que colocaremos todas as funções do CRUD. 19 | 20 | Abra ``app/controllers/artigos_controllers.rb`` novamente e escreva: 21 | 22 | ```ruby 23 | class ArtigosController < ApplicationController 24 | def new 25 | end 26 | end 27 | ``` 28 | 29 | Agora tente criar um novo Artigo indo em [localhost:3000/artigos/new](http://localhost:3000/artigos/new) 30 | 31 | ![Erro na visualização dos artigos](../../assets/inserindo-dados/erro-1.png) 32 | 33 | Como você pode ver acima, ocorreu um erro, pois como no Welcome, precisamos criar uma *view*, pois o *Controller* vai fazer a requisição, a *view* vai receber esses dados e mostrar ele ao usuário. 34 | 35 | Abra ``apps/views/artigos/new.html.erb``, que é o arquivo da view do nosso *Controller* Artigos e escreva 36 | 37 | ```html 38 |

Novo Artigo

39 | ``` 40 | 41 | Pronto!, agora quando você entra em ``artigos/new`` aparece uma página simples, agora precisamos inserir o formulário e a função de criar dentro do *Controller* dos artigos. 42 | 43 | Agora entre no ``apps/views/artigos/new.html.erb`` e ESCREVA: 44 | 45 | ```ruby 46 | <%= form_with scope: :artigo, url: artigos_path, local: true do |form| %> 47 |

48 | <%= form.label :titulo %>
49 | <%= form.text_field :titulo %> 50 |

51 | 52 |

53 | <%= form.label :texto %>
54 | <%= form.text_area :texto %> 55 |

56 | 57 |

58 | <%= form.submit %> 59 |

60 | <% end %> 61 | ``` 62 | 63 | Explicação do código acima: 64 | 65 | - A primeira linha inicia o formulário, o ``form_with scope: :artigo`` determina que o form será para o nosso *Controller* Artigos. 66 | - ``url: artigos_path```diz que quando o form for enviado, o usuário será redirecionado para a página que lista os artigos, que iremos fazer mais tarde. 67 | - Cada ``

`` contém o input que será enviado ao *Controller*, com o ``:titulo`` ou ``:texto``. 68 | - o ``form.submit`` cria o botão que será usado para enviar o formulário. 69 | 70 | Agora, quando você tentar enviar o formulário, irá aparecer isto na tela: 71 | 72 | ![Erro no envio do formulário](../../assets/inserindo-dados/erro-2.png) 73 | 74 | Como nós não criamos a função para salvar os dados que criamos no formulário, o Rails dá este erro, vamos então criar esta função, mas vamos apenas mandar os dados serem mostrados na tela. 75 | 76 | Abra o arquivo ``apps/controllers/artigos_controller.rb`` e escreva: 77 | 78 | ```ruby 79 | class ArtigosController < ApplicationController 80 | def new 81 | end 82 | 83 | def create 84 | render plain: params[:artigo] 85 | end 86 | end 87 | ``` 88 | 89 | Agora quando inserimos um título e texto no formulário seremos redirecionados á uma página vazia, apenas com os valores que inserimos: 90 | 91 | ![Output](../../assets/inserindo-dados/output-1.png) 92 | 93 | No caso, o Output dará o titulo sendo "Ruby on Rails" e o texto sendo "é um framework Ruby para Backend" 94 | 95 | ## Salvando no Banco de Dados 96 | 97 | Para salvarmos no Banco de Dados precisaremos criar um *Model*, um *Model* representa uma tabela no banco de dados, que no caso, iremos usar o SQLite, para criarmos um novo *Model* chamado Artigo é bem simples: 98 | 99 | ``rails generate model Artigo titulo:string texto:text`` 100 | 101 | Estamos criando uma tabela chamada Artigo, com as colunas título e texto, o título é uma string enquanto texto é um text, podendo guardar uma string muito grande. 102 | 103 | Agora você precisa rodar essa migration, para ela se tornar efetiva, em Rails é assim: 104 | 105 | ``rails db:migrate`` 106 | 107 | Pronto, o *model* foi criado. 108 | 109 | Agora vamos voltar ao ``apps/controllers/artigos_controller.rb`` e vamos alterar a função de create. 110 | 111 | ```ruby 112 | class ArtigosController < ApplicationController 113 | def new 114 | end 115 | 116 | def create 117 | @artigo = Artigo.new(artigo_params) 118 | 119 | @artigo.save 120 | redirect_to @artigo 121 | end 122 | 123 | private 124 | def artigo_params 125 | params.require(:artigo).permit(:titulo, :texto) 126 | end 127 | end 128 | ``` 129 | 130 | No códgio acima fazemos: 131 | 132 | - A função create começa criando um novo artigo, passando como parametro uma função chamada ``artigo_params``. 133 | - A função artigo_params é uma camada de segurança, pois ela só vai permitir que o título e o texto do artigo sejam enviados. 134 | - O ``@artigo.save`` salva o artigo no banco de dados, e logo depois, redireciona o usuário a uma página que mostra o artigo que ele enviou. 135 | 136 | Tente enviar um novo artigo, ele será escrito no banco de dados, mas aparecerá este erro na tela: 137 | 138 | ![Erro com a visualização do formulário](../../assets/inserindo-dados/erro-3.png) 139 | 140 | Este erro ocorre pois não criamos uma função show para mostrar o artigo que foi criado, e é isso que iremos fazer agora. 141 | 142 | Abra ``apps/controllers/artigos_controller.rb`` e escreva a função show 143 | 144 | ```ruby 145 | class ArtigosController < ApplicationController 146 | def show 147 | @artigo = Artigo.find(params[:id]) 148 | end 149 | 150 | def new 151 | end 152 | 153 | def create 154 | @artigo = Artigo.new(artigo_params) 155 | 156 | @artigo.save 157 | redirect_to @artigo 158 | end 159 | 160 | private 161 | def artigo_params 162 | params.require(:artigo).permit(:titulo, :texto) 163 | end 164 | end 165 | ``` 166 | 167 | Podemos ver que o código está igual, a diferença é que temos uma função chamada show, que procura um artigo passando como parâmetro o id dele, que é numérico. 168 | 169 | Agora vamos criar um arquivo em ``app/views/artigos/show.html.erb``, que é a view do show, assim, poderemos mostrar o artigo que foi feito pelo usuário para o usuário, escreva este código nele: 170 | 171 | ```ruby 172 |

173 | Título: 174 | <%= @artigo.titulo %> 175 |

176 | 177 |

178 | Texto: 179 | <%= @artigo.texto %> 180 |

181 | ``` 182 | 183 | Como podemos ver nele, dentro do artigo há todos os dados referentes ao artigo, que no caso, é o seu título e o seu texto, que serão mostrados na tela. 184 | 185 | E pronto!, lembra daquele artigo que enviamos pelo formulário e que não podiamos ver? agora conseguimos, apenas atualize a página e você verá o artigo: 186 | 187 | ![Output 2](../../assets/inserindo-dados/output-2.png) 188 | 189 | E pronto! é dessa maneira que podemos ver o artigo que acabamos de criar. 190 | 191 | ## Proximo => 192 | 193 | [Listando Todos os Artigos](../listando-dados/README.md) --------------------------------------------------------------------------------