Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

WIP The Rails Command Line > 1. Command Line Basics #707

Draft
wants to merge 4 commits into
base: main
Choose a base branch
from
Draft

WIP The Rails Command Line > 1. Command Line Basics #707

Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
ee2be8b
WIP The Rails Command Line > 1. Command Line Basics #706
thaisjsoares Dec 29, 2021
c5899a0
WIP The Rails Command Line > 1. Command Line Basics #706
thaisjsoares Dec 29, 2021
33561ba
WIP The Rails Command Line > 1. Command Line Basics campuscode#706
thaisjsoares Jan 1, 2022
7b27c01
WIP The Rails Command Line > 1. Command Line Basics campuscode#706
thaisjsoares Jan 6, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
118 changes: 60 additions & 58 deletions pt-BR/command_line.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -70,9 +70,10 @@ Vamos criar uma aplicação Rails simples passando por cada um destes comandos.

### `rails new`

The first thing we'll want to do is create a new Rails application by running the `rails new` command after installing Rails.
A primeira coisa que precisamos fazer é criar uma nova aplicação Rails executando o comando
`rails new` após a instalação do Rails.

INFO: You can install the rails gem by typing `gem install rails`, if you don't have it already.
INFO: Você pode instalar a *gem* rails digitando `gem install rails`, caso ainda não esteja instalada.

```bash
$ rails new commandsapp
Expand All @@ -89,35 +90,36 @@ $ rails new commandsapp
run bundle install
```

Rails will set you up with what seems like a huge amount of stuff for such a tiny command! You've got the entire Rails directory structure now with all the code you need to run our simple application right out of the box.
O Rails criará o que parece ser um monte de coisas pra um comando tão pequeno! Agora você tem a estrutura de diretorios do Rails inteira, com todo o código que você precisa pra rodar nossa aplicação simples sem ter que configurar mais nada.

If you wish to skip some files or components from being generated, you can append the following arguments to your `rails new` command:
Se você quiser fazer com que alguns arquivos ou componentes não sejam gerados, você pode
acrescentar os seguintes arumentos ao seu comando `rails new`:

| Argument | Description |
| Argumento | Descricão |
| ----------------------- | ----------------------------------------------------------- |
| `--skip-gemfile` | Don't create a Gemfile |
| `--skip-git` | Skip .gitignore file |
| `--skip-keeps` | Skip source control .keep files |
| `--skip-action-mailer` | Skip Action Mailer files |
| `--skip-action-text` | Skip Action Text gem |
| `--skip-active-record` | Skip Active Record files |
| `--skip-active-storage` | Skip Active Storage files |
| `--skip-puma` | Skip Puma related files |
| `--skip-action-cable` | Skip Action Cable files |
| `--skip-sprockets` | Skip Sprockets files |
| `--skip-spring` | Don't install Spring application preloader |
| `--skip-listen` | Don't generate configuration that depends on the listen gem |
| `--skip-javascript` | Skip JavaScript files |
| `--skip-turbolinks` | Skip turbolinks gem |
| `--skip-test` | Skip test files |
| `--skip-system-test` | Skip system test files |
| `--skip-bootsnap` | Skip bootsnap gem |
| `--skip-gemfile` | Não cria um Gemfile |
| `--skip-git` | Pula o arquivo .gitignore |
| `--skip-keeps` | Pula os arquivos .keep de controle de origem |
| `--skip-action-mailer` | Pula os arquivos *Action Mailer* |
| `--skip-action-text` | Pula a *gem* *Action Text* |
| `--skip-active-record` | Pula os arquivos *Active Record* |
| `--skip-active-storage` | Pula os arquivos *Active Storage files* |
| `--skip-puma` | Pula os arquivos do Puma |
| `--skip-action-cable` | Pula os arquivos *Action Cable* |
| `--skip-sprockets` | Pula os arquivos do Sprockets |
| `--skip-spring` | Não instala a aplicação de pré-carregamento Spring |
| `--skip-listen` | Não gera configuração que depende da *gem* listen |
| `--skip-javascript` | Pula os arquivos JavaScript |
| `--skip-turbolinks` | Pula a *gem* turbolinks |
| `--skip-test` | Pula os arquivos de teste |
| `--skip-system-test` | Pula os arquivos de teste de sistema |
| `--skip-bootsnap` | Pula a *gem* bootsnap |

### `bin/rails server`

The `bin/rails server` command launches a web server named Puma which comes bundled with Rails. You'll use this any time you want to access your application through a web browser.
O coomando `bin/rails server` inicia um servidor web chamado Puma que vem com o Rails. Você vai utilizá-lo sempre que quiser acessar sua aplicação por um navegador.

With no further work, `bin/rails server` will run our new shiny Rails app:
Sem que precisemos fazer mais nada, o comando `bin/rails server` executa a nossa aplicação Rails novinha em folha:

```bash
$ cd commandsapp
Expand All @@ -133,23 +135,23 @@ Puma starting in single mode...
Use Ctrl-C to stop
```

With just three commands we whipped up a Rails server listening on port 3000. Go to your browser and open [http://localhost:3000](http://localhost:3000), you will see a basic Rails app running.
Com apenas três comandos, produzimos um servidor Rails escutando na porta 3000. Vá até o seu navegador, abra [http://localhost:3000](http://localhost:3000) e veja a aplicação Rails básica rodando.

INFO: You can also use the alias "s" to start the server: `bin/rails s`.
INFO: Você também pode utilizar a abreviação "s" pra iniciar o servidor: `bin/rails s`.

The server can be run on a different port using the `-p` option. The default development environment can be changed using `-e`.
O servidor pode ser executado utilizando uma porta diferente com a opção `-p`. O ambiente de desenvolvimento padrão pode ser modificado usando `-e`.

```bash
$ bin/rails server -e production -p 4000
```

The `-b` option binds Rails to the specified IP, by default it is localhost. You can run a server as a daemon by passing a `-d` option.
A opção `-b` vincula o Rails a um IP especificado que, por padrão, é o *localhost*. Você pode rodar um servidor como *daemon* passando a opção `-d`.

### `bin/rails generate`

The `bin/rails generate` command uses templates to create a whole lot of things. Running `bin/rails generate` by itself gives a list of available generators:
O comando `bin/rails generate` usa um *template* pra criar um monte de coisas. Executar `bin/rails generate` sozinho retorna uma lista de vários geradores disponíveis:

INFO: You can also use the alias "g" to invoke the generator command: `bin/rails g`.
INFO: Você pode usar o atalho "g" para chamar o comando *generate*: `bin/rails g`.

```bash
$ bin/rails generate
Expand All @@ -169,13 +171,13 @@ Rails:
...
```

NOTE: You can install more generators through generator gems, portions of plugins you'll undoubtedly install, and you can even create your own!
NOTE: Você pode instalar mais geradores por meio de *gems* de geradores, partes de *plugins* que você sem dúvida vai instalar, e você pode até criar seus próprios!

Using generators will save you a large amount of time by writing **boilerplate code**, code that is necessary for the app to work.
Usar geradores economiza bastante tempo porque envolve escrever **código *boilerplate*** (ou padrão), código necessário para que a aplicação funcione.

Let's make our own controller with the controller generator. But what command should we use? Let's ask the generator:
Vamos fazer nosso próprio *controller* com o gerador de *controllers*. Mas qual comando devemos usar? Vamos perguntar ao gerador:

INFO: All Rails console utilities have help text. As with most *nix utilities, you can try adding `--help` or `-h` to the end, for example `bin/rails server --help`.
INFO: Todos os serviços do console do Rails têm textos de ajuda. Como ocorre com a maioria dos comandos \*nix, você pode tentar adicionar `--help` ou `-h` no final (por exemplo: `bin/rails server --help`).

```bash
$ bin/rails generate controller
Expand All @@ -201,7 +203,7 @@ Example:
Helper: app/helpers/credit_cards_helper.rb
```

The controller generator is expecting parameters in the form of `generate controller ControllerName action1 action2`. Let's make a `Greetings` controller with an action of **hello**, which will say something nice to us.
O gerador de *controller* precisa de parâmtros no seguinte formato: `generate controller NomeDoController ação1 ação2`. Vamos fazer o *controller* `Greetings` com uma ação **hello**, que dirá algo legal pra gente.

```bash
$ bin/rails generate controller Greetings hello
Expand All @@ -220,37 +222,37 @@ $ bin/rails generate controller Greetings hello
create app/assets/stylesheets/greetings.scss
```

What all did this generate? It made sure a bunch of directories were in our application, and created a controller file, a view file, a functional test file, a helper for the view, a JavaScript file, and a stylesheet file.
O que foi tudo isso que o comando gerou? Ele gerou vários diretórios na nossa aplicação e criou um arquivo de *controller*, um arquivo de *view*, um arquivo de teste funcional, um *helper* pra *view*, um arquivo Javascript e um arquivo de folha de estilo em cascata.

Check out the controller and modify it a little (in `app/controllers/greetings_controller.rb`):
Dê uma olhada no *controller* e faça a seguinte pequena modificação no arquivo `app/controllers/greetings_controller.rb`:

```ruby
class GreetingsController < ApplicationController
def hello
@message = "Hello, how are you today?"
@message = "Olá. Como vai você?"
end
end
```

Then the view, to display our message (in `app/views/greetings/hello.html.erb`):
Agora edite a *view* para que ela exiba a nossa mensagem (em `app/views/greetings/hello.html.erb`):

```erb
<h1>A Greeting for You!</h1>
<h1>Uma mensagem pra você!</h1>
<p><%= @message %></p>
```

Fire up your server using `bin/rails server`.
Rode o seu servidor usando o comando `bin/rails server`.

```bash
$ bin/rails server
=> Booting Puma...
```

The URL will be [http://localhost:3000/greetings/hello](http://localhost:3000/greetings/hello).
O URL será [http://localhost:3000/greetings/hello](http://localhost:3000/greetings/hello).

INFO: With a normal, plain-old Rails application, your URLs will generally follow the pattern of http://(host)/(controller)/(action), and a URL like http://(host)/(controller) will hit the **index** action of that controller.
INFO: Em uma aplicação comum de Rails, seus URLs vão geralmente seguir o seguinte padrão: http://(host)/(controller)/(action). Um URL como http://(host)/(controller) vai direcionar você pra ação **index** daquele *controller*.

Rails comes with a generator for data models too.
O Rails também vem com um gerador para os *models* de dados.

```bash
$ bin/rails generate model
Expand All @@ -272,11 +274,11 @@ Description:
...
```

NOTE: For a list of available field types for the `type` parameter, refer to the [API documentation](https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-add_column) for the add_column method for the `SchemaStatements` module. The `index` parameter generates a corresponding index for the column.
NOTA: Para obter uma lista dos tipos de campos disponíveis para o parâmetro `type`, consulte a [documentação API](https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-add_column) para o métodos *add_column* (adicionar coluna) do módulo `SchemaStatements`. O parâmetro `index` gera um índice correspondente para a coluna.

But instead of generating a model directly (which we'll be doing later), let's set up a scaffold. A **scaffold** in Rails is a full set of model, database migration for that model, controller to manipulate it, views to view and manipulate the data, and a test suite for each of the above.
Mas em vez de gerar o *model* diretamente (o que faremos depois), vamos configurar um *scaffold*. Um ***scaffold*** em Rails é um conjunto completo de *model*, a *migration* da base de dados para esse *model*, o *controller* para manipulá-lo, *views* para visualizar e manipular os dados e um conjunto de testes para cada um dos itens descritos acima.

We will set up a simple resource called "HighScore" that will keep track of our highest score on video games we play.
Vamos configurar uma *resource* simples chamado "HighScore" que contabiliza nossas pontuações mais altas no jogos de videogame que jogamos.

```bash
$ bin/rails generate scaffold HighScore game:string score:integer
Expand Down Expand Up @@ -314,9 +316,9 @@ $ bin/rails generate scaffold HighScore game:string score:integer
create app/assets/stylesheets/scaffolds.scss
```

The generator checks that there exist the directories for models, controllers, helpers, layouts, functional and unit tests, stylesheets, creates the views, controller, model and database migration for HighScore (creating the `high_scores` table and fields), takes care of the route for the **resource**, and new tests for everything.
O gerador verifica os diretórios existentes em busca de *models*, *controllers*, *helpers*, layouts, testes funcionais e unitários, folhas de estilo de cascata, e cria as *views*, os *controllers* e a *migration* de banco de dados para *HighScore* (criando a tabela e os campos `high_scores`. Além disso, o gerador se encarrega da rota para a ***resource*** e dos novos testes para tudo.

The migration requires that we **migrate**, that is, run some Ruby code (living in that `20130717151933_create_high_scores.rb`) to modify the schema of our database. Which database? The SQLite3 database that Rails will create for you when we run the `bin/rails db:migrate` command. We'll talk more about that command below.
A *migration* precise que migremos, ou seja, que executemos um código em Ruby (contido em `20130717151933_create_high_scores.rb`) que modifica o *schema* (esquema) do nosso banco de dados. Mas qual banco de dados? O banco de dados SQLite3 que o Rails vai criar para nós quando executarmos o comando `bin/rails db:migrate`. Falaremos mais sobre esse comando a seguir.

```bash
$ bin/rails db:migrate
Expand All @@ -326,21 +328,21 @@ $ bin/rails db:migrate
== CreateHighScores: migrated (0.0019s) ======================================
```

INFO: Let's talk about unit tests. Unit tests are code that tests and makes assertions
about code. In unit testing, we take a little part of code, say a method of a model,
and test its inputs and outputs. Unit tests are your friend. The sooner you make
peace with the fact that your quality of life will drastically increase when you unit
test your code, the better. Seriously. Please visit
[the testing guide](https://guides.rubyonrails.org/testing.html) for an in-depth
look at unit testing.
INFO: Vamos falar sobre testes unitários. Testes unitários são códigos que testam e
fazem afirmações sobre o código. Com testes unitários, pegamos um pequeno trecho de código,
digamos, um método ou um *model*, e testamos suas entradas e saídas. Testes unitários são
seus amigos. Quantos antes vocês aceitar o fato de que a sua qualidade de vida vai aumentar
drasticamente quando você faz testes unitários no seu código, melhor. Sério. Por favor, vá
em [the testing guide](https://guides.rubyonrails.org/testing.html) para uma visão mais
aprofundada de testes unitários.

Let's see the interface Rails created for us.
Vejamos a interface que o Rails criou para nós.

```bash
$ bin/rails server
```

Go to your browser and open [http://localhost:3000/high_scores](http://localhost:3000/high_scores), now we can create new high scores (55,160 on Space Invaders!)
Abra o seu navegador e digite [http://localhost:3000/high_scores](http://localhost:3000/high_scores). Agora podemos criar novas pontuações máximas (55,160 no *Space Invaders*!)

### `bin/rails console`

Expand Down