Base de Conhecimento

Introdução

O Rails é uma estrutura de aplicativos da Web escrita em Ruby . É necessária uma abordagem opinativa do desenvolvimento de aplicativos, assumindo que as convenções definidas atendem melhor aos desenvolvedores onde existe um objetivo comum. O Rails, portanto, oferece convenções para lidar com roteamento, dados com estado, gerenciamento de ativos e muito mais para fornecer a funcionalidade de linha de base que a maioria dos aplicativos Web precisa.

O Rails segue o padrão de arquitetura MCV ( Model-View-Controller ), que separa a lógica de um aplicativo, localizada nos modelos, do roteamento e apresentação das informações do aplicativo. Essa estrutura organizacional - junto com outras convenções que permitem aos desenvolvedores extrair o código em auxiliares e parciais - garante que o código do aplicativo não seja repetido desnecessariamente .

Neste tutorial, você criará um aplicativo Rails que permitirá aos usuários postar informações sobre tubarões e seu comportamento. Será um bom ponto de partida para o desenvolvimento futuro de aplicativos.

Pré-requisitos

Para seguir este tutorial, você precisará de:

• Uma máquina local ou servidor de desenvolvimento executando o Ubuntu 18.04. Sua máquina de desenvolvimento deve ter um usuário não raiz com privilégios administrativos e um firewall configurado com ufw. Para obter instruções sobre como configurar isso, consulte o tutorial Configuração inicial do servidor com o Ubuntu 18.04 .
• Node.js e npm instalados em sua máquina local ou servidor de desenvolvimento. Este tutorial usa Node.js versão 10.16.3 e versão npm 6.9.0 . Para obter orientação sobre a instalação do Node.js e do npm no Ubuntu 18.04, siga as instruções na seção "Instalando usando um PPA" em Como instalar o Node.js no Ubuntu 18.04 .
• Ruby, rbenv e Rails instalados em sua máquina local ou servidor de desenvolvimento, seguindo as etapas 1 a 4 em Como instalar o Ruby on Rails com rbenv no Ubuntu 18.04 . Este tutorial usa Ruby 2.5.1 , rbenv 1.1.2 e Rails 5.2.0 .

Etapa 1 - Instalando o SQLite3

Antes de criar nosso aplicativo shark Rails, precisaremos garantir que tenhamos um banco de dados para armazenar dados do usuário. O Rails está configurado para usar o SQLite por padrão, e isso geralmente é uma boa escolha no desenvolvimento. Como os dados de nossos aplicativos não exigem uma extensibilidade programática de alto nível, o SQLite atenderá às nossas necessidades.

Primeiro, atualize o índice do seu pacote:

• sudo apt update

Em seguida, instale os pacotes sqlite3e libsqlite3-dev:

• sudo apt install sqlite3 libsqlite3-dev

Isso instalará o SQLite e seus arquivos de desenvolvimento necessários.

Verifique sua versão para confirmar que a instalação foi bem-sucedida:

• sqlite3 --version

3.22.0 2018-01-22 18:45:57 0c55d179733b46d8d0ba4d88e01a25e10677046ee3da1d5b1581e86726f2alt1

Com o SQLite instalado, você está pronto para começar a desenvolver seu aplicativo.

Etapa 2 - Criando um novo projeto Rails

Com o nosso banco de dados instalado, podemos criar um novo projeto Rails e olhada em alguns do código clichê padrão que Rails dá-nos com o rails newcomando .

Crie um projeto chamado sharkappcom o seguinte comando:

• rails new sharkapp

Você verá muitas informações dizendo o que o Rails está criando para o seu novo projeto. A saída abaixo destaca alguns arquivos, diretórios e comandos significativos:

     create  
     . . .
     create  Gemfile 
     . . .
      create  app 
      . . .
      create  app/controllers/application_controller.rb
      . . .
      create  app/models/application_record.rb
      . . .
      create  app/views/layouts/application.html.erb
      . . . 
      create  config
      create  config/routes.rb
      create  config/application.rb
      . . . 
      create  config/environments
      create  config/environments/development.rb
      create  config/environments/production.rb
      create  config/environments/test.rb
      . . .
      create  config/database.yml
      create  db
      create  db/seeds.rb
      . . . 
         run  bundle install
      . . . 
Bundle complete! 18 Gemfile dependencies, 78 gems now installed.
Use `bundle info [gemname]` to see where a bundled gem is installed.
      . . . 
* bin/rake: Spring inserted
* bin/rails: Spring inserted

A saída destacada aqui informa que o Rails criou o seguinte:

• Gemfile: Este arquivo lista as dependências de gemas para seu aplicativo. Uma gem é um pacote de software Ruby e um Gemfile permite gerenciar as necessidades de software do seu projeto.
• app: O appdiretório é onde reside o código principal do aplicativo. Isso inclui os modelos, controladores, visualizações, ativos, auxiliares e malas diretas que compõem o próprio aplicativo. Rails dá-lhe algum clichê de nível de aplicativo para o modelo MCV para começar em arquivos como app/models/application_record.rb, app/controllers/application_controller.rb, e app/views/layouts/application.html.erb.
• config: Este diretório contém as definições de configuração do seu aplicativo:
  • config/routes.rb: As declarações de rota do seu aplicativo estão nesse arquivo.
  • config/application.rb: As configurações gerais dos componentes do seu aplicativo estão localizadas neste arquivo.
• config/environments: É neste diretório que vivem as definições de configuração para seus ambientes. Rails inclui três ambientes por padrão: development, production, e test.
• config/database.yml: Definições de configuração de banco de dados viver neste arquivo, que é dividido em quatro seções: default, development, production, e test. Graças ao Gemfile que acompanha o rails newcomando, que incluiu a sqlite3gem, nosso config/database.ymlarquivo já possui seu adapterparâmetro definido sqlite3, especificando que usaremos um banco de dados SQLite com este aplicativo.
• db: Esta pasta inclui um diretório para migrações de banco de dados chamado migrate, junto com os arquivos schema.rbe seeds.rb. schema.dbcontém informações sobre seu banco de dados, enquanto seeds.rbé onde você pode colocar dados iniciais para o banco de dados.

Por fim, o Rails executa o bundle installcomando para instalar as dependências listadas no seu Gemfile.

Depois que tudo estiver configurado, navegue até o sharkappdiretório:

• cd sharkapp

Agora você pode iniciar os trilhos do servidor para garantir que seu aplicativo está funcionando, usando o rails servercomando . Se você estiver trabalhando em sua máquina local, digite:

• rails server

Como o Rails é vinculado localhostpor padrão, agora você pode acessar seu aplicativo navegando no navegador para locahost:3000onde você verá a seguinte imagem:

Se você estiver trabalhando em um servidor de desenvolvimento, primeiro verifique se as conexões são permitidas na porta 3000:

• sudo ufw allow 3000

Em seguida, inicie o servidor com o --bindingsinalizador para vincular ao IP do servidor:

• rails server --binding=your_server_ip

Navegue para no seu navegador, onde você verá a mensagem de boas-vindas do Rails.http://your_server_ip:3000

Depois de olhar em volta, você pode parar o servidor com CTRL+C.

Com seu aplicativo criado e no local, você está pronto para começar a construir a partir do padrão do Rails para criar um aplicativo exclusivo.

Etapa 3 - Andaimes do aplicativo

Para criar nosso aplicativo de informações sobre tubarões, precisaremos criar um modelo para gerenciar os dados do aplicativo, visualizações para permitir a interação do usuário com esses dados e um controlador para gerenciar a comunicação entre o modelo e as visualizações. Para criar essas coisas, usaremos o rails generate scaffoldcomando, que nos fornecerá um modelo, uma migração de banco de dados para alterar o esquema do banco de dados, um controlador, um conjunto completo de visualizações para gerenciar as operações Criar, Ler, Atualizar e Excluir (CRUD) para o aplicativo e modelos para parciais, auxiliares e testes.

Como o generate scaffoldcomando faz muito trabalho para nós, examinaremos mais de perto os recursos que ele cria para entender o trabalho que o Rails está fazendo sob o capô.

Nosso generate scaffoldcomando incluirá o nome do nosso modelo e os campos que queremos em nossa tabela de banco de dados. O Rails usa o Active Record para gerenciar relacionamentos entre os dados do aplicativo, construídos como objetos com modelos, e o banco de dados do aplicativo. Cada um dos nossos modelos é uma classe Ruby , enquanto também é herdada da ActiveRecord::Baseclasse. Isso significa que podemos trabalhar com nossa classe de modelo da mesma maneira que trabalharíamos com uma classe Ruby, além de extrair métodos do Active Record. O Active Record garantirá que cada classe seja mapeada para uma tabela em nosso banco de dados e cada instância dessa classe para uma linha nessa tabela.

Digite o seguinte comando para gerar um Sharkmodelo, controlador e visualizações associadas:

• rails generate scaffold Shark name:string facts:text

Com name:stringe facts:textestamos fornecendo ao Rails informações sobre os campos que gostaríamos na nossa tabela de banco de dados e o tipo de dados que eles deveriam aceitar. Ambos nos darão espaço para inserir o que gostaríamos, mas textpermitirão mais caracteres para fatos sobre tubarões.

Ao digitar esse comando, você verá novamente uma longa lista de resultados que explica tudo o que o Rails está gerando para você. A saída abaixo destaca algumas das coisas mais significativas para nossa configuração:

      invoke  active_record
      create    db/migrate/20190804181822_create_sharks.rb
      create    app/models/shark.rb
      . . .
      invoke  resource_route
       route    resources :sharks
      invoke  scaffold_controller
      create    app/controllers/sharks_controller.rb
      invoke    erb
      create      app/views/sharks
      create      app/views/sharks/index.html.erb
      create      app/views/sharks/edit.html.erb
      create      app/views/sharks/show.html.erb
      create      app/views/sharks/new.html.erb
      create      app/views/sharks/_form.html.erb
      . . .

Rails criou o modelo de app/models/shark.rbe uma migração de banco de dados para ir com ele: . O registro de data e hora no seu arquivo de migração será diferente do que você vê aqui.db/migrate/20190804181822_create_sharks.rb

Ele também criou um controlador, app/controllers/sharks_controller.rbbem como as visualizações associadas às operações CRUD de nosso aplicativo, coletadas em app/views/sharks. Entre essas visualizações, existe uma parcial,, _form.html.erbque contém o código usado nas visualizações.

Por fim, o Rails adicionou uma nova rota,, resources :sharksa config/routes.rb. Isso permite que o roteador Rails corresponda às solicitações HTTP recebidas com o sharkscontrolador e suas visualizações associadas.

Embora o Rails tenha feito muito do trabalho de construir nosso código de aplicativo para nós, vale a pena dar uma olhada em alguns arquivos para entender o que está acontecendo.

Primeiro, vejamos o arquivo do controlador com o seguinte comando:

• cat app/controllers/sharks_controller.rb

class SharksController < ApplicationController
  before_action :set_shark, only: [:show, :edit, :update, :destroy]

  # GET /sharks
  # GET /sharks.json
  def index
    @sharks = Shark.all
  end

  # GET /sharks/1
  # GET /sharks/1.json
  def show
  end

  # GET /sharks/new
  def new
    @shark = Shark.new
  end

  # GET /sharks/1/edit
  def edit
  end

  # POST /sharks
  # POST /sharks.json
  def create
    @shark = Shark.new(shark_params)

    respond_to do |format|
      if @shark.save
        format.html { redirect_to @shark, notice: 'Shark was successfully created.' }
        format.json { render :show, status: :created, location: @shark }
      else
        format.html { render :new }
        format.json { render json: @shark.errors, status: :unprocessable_entity }
      end
    end
  end

  # PATCH/PUT /sharks/1
  # PATCH/PUT /sharks/1.json
  def update
    respond_to do |format|
      if @shark.update(shark_params)
        format.html { redirect_to @shark, notice: 'Shark was successfully updated.' }
        format.json { render :show, status: :ok, location: @shark }
      else
        format.html { render :edit }
        format.json { render json: @shark.errors, status: :unprocessable_entity }
      end
    end
  end

  # DELETE /sharks/1
  # DELETE /sharks/1.json
  def destroy
    @shark.destroy
    respond_to do |format|
      format.html { redirect_to sharks_url, notice: 'Shark was successfully destroyed.' }
      format.json { head :no_content }
    end
  end

  private
    # Use callbacks to share common setup or constraints between actions.
    def set_shark
      @shark = Shark.find(params[:id])
    end

    # Never trust parameters from the scary internet, only allow the white list through.
    def shark_params
      params.require(:shark).permit(:name, :facts)
    end
end

O controlador é responsável por gerenciar como as informações são buscadas e passadas para o modelo associado e como elas são associadas a visualizações específicas. Como você pode ver, nosso sharkscontrolador inclui uma série de métodos que são mapeados aproximadamente para operações CRUD padrão. No entanto, existem mais métodos do que funções CRUD, para permitir eficiência no caso de erros.

Por exemplo, considere o createmétodo:

. . .
  def create
    @shark = Shark.new(shark_params)

    respond_to do |format|
      if @shark.save
        format.html { redirect_to @shark, notice: 'Shark was successfully created.' }
        format.json { render :show, status: :created, location: @shark }
      else
        format.html { render :new }
        format.json { render json: @shark.errors, status: :unprocessable_entity }
      end
    end
  end
. . . 

Se uma nova instância da Sharkclasse for salva com sucesso, redirect_togerará uma nova solicitação que será direcionada ao controlador. Isso será uma GETsolicitação e será tratada pelo showmétodo, que mostrará ao usuário o tubarão que acabou de adicionar.

Se houver uma falha, o Rails renderizará o app/views/sharks/new.html.erbmodelo novamente, em vez de fazer outra solicitação ao roteador, dando aos usuários outra chance de enviar seus dados.

Além do controlador de tubarões, o Rails nos forneceu um modelo para uma indexvisualização, que é mapeada para o indexmétodo em nosso controlador. Usaremos isso como a visualização raiz do nosso aplicativo, por isso vale a pena dar uma olhada nele.

Digite o seguinte para gerar o arquivo:

• cat app/views/sharks/index.html.erb

<p id="notice"><%= notice %></p>

<h1>Sharks</h1>

<table>
  <thead>
    <tr>
      <th>Name</th>
      <th>Facts</th>
      <th colspan="3"></th>
    </tr>
  </thead>

  <tbody>
    <% @sharks.each do |shark| %>
      <tr>
        <td><%= shark.name %></td>
        <td><%= shark.facts %></td>
        <td><%= link_to 'Show', shark %></td>
        <td><%= link_to 'Edit', edit_shark_path(shark) %></td>
        <td><%= link_to 'Destroy', shark, method: :delete, data: { confirm: 'Are you sure?' } %></td>
      </tr>
    <% end %>
  </tbody>
</table>

<br>

<%= link_to 'New Shark', new_shark_path %>

A indexvisualização itera através das instâncias de nossa Sharkclasse, que foram mapeadas para a sharkstabela em nosso banco de dados. Usando o modelo ERB , a exibição gera cada campo da tabela associada a uma instância individual de tubarão: namee facts.

A exibição usa o link_toauxiliar para criar um hiperlink, com a sequência fornecida como texto para o link e o caminho fornecido como destino. Os caminhos em si são possíveis através dos auxiliares que se tornaram disponíveis quando definimos a sharksrota de recursos com o rails generate scaffoldcomando

Além de observar nossa indexvisão, também podemos dar uma olhada na newvisão para ver como o Rails usa parciais nas visualizações. Digite o seguinte para gerar o app/views/sharks/new.html.erbmodelo:

• cat app/views/sharks/new.html.erb

<h1>New Shark</h1>

<%= render 'form', shark: @shark %>

<%= link_to 'Back', sharks_path %>

Embora esse modelo pareça não ter campos de entrada para uma nova entrada de tubarão, a referência para render 'form'nos diz que o modelo está puxando a _form.html.erbparcial, que extrai o código que é repetido nas visualizações.

Olhar para esse arquivo nos dará uma noção completa de como uma nova instância de shark é criada:

• cat app/views/sharks/_form.html.erb

<%= form_with(model: shark, local: true) do |form| %>
  <% if shark.errors.any? %>
    <div id="error_explanation">
      <h2><%= pluralize(shark.errors.count, "error") %> prohibited this shark from being saved:</h2>

      <ul>
      <% shark.errors.full_messages.each do |message| %>
        <li><%= message %></li>
      <% end %>
      </ul>
    </div>
  <% end %>

  <div class="field">
    <%= form.label :name %>
    <%= form.text_field :name %>
  </div>

  <div class="field">
    <%= form.label :facts %>
    <%= form.text_area :facts %>
  </div>

  <div class="actions">
    <%= form.submit %>
  </div>
<% end %>

Este modelo faz uso do auxiliar de formulário . Os auxiliares de formulário são projetados para facilitar a criação de novos objetos a partir da entrada do usuário usando os campos e o escopo de modelos específicos. Aqui, assume como argumento, e o novo objeto criador de formulários que ele cria possui entradas de campo que correspondem aos campos na tabela. Assim, os usuários têm campos de formulário para inserir um tubarão e um tubarão .form_with form_withmodel: sharksharksnamefacts

O envio deste formulário criará uma resposta JSON com dados do usuário que o restante do seu aplicativo pode acessar por meio do método params , que cria um ActionController::Parametersobjeto com esses dados.

Agora que você sabe o que rails generate scaffoldfoi produzido para você, pode definir a visualização raiz do seu aplicativo.

Etapa 4 - Criando a visualização raiz do aplicativo e testando a funcionalidade

Idealmente, você deseja que a página de destino do seu aplicativo seja mapeada para a raiz do aplicativo, para que os usuários possam entender imediatamente o objetivo do aplicativo.

Há várias maneiras de lidar com isso: por exemplo, você pode criar um Welcomecontrolador e uma indexexibição associada , o que daria aos usuários uma página de destino genérica que também poderia se vincular a diferentes partes do aplicativo. No nosso caso, no entanto, fazer com que os usuários acessem nossa indexvisão de tubarões será uma introdução suficiente ao objetivo do aplicativo por enquanto.

Para configurar isso, você precisará modificar as configurações de roteamento config/routes.rbpara especificar a raiz do aplicativo.

Abra config/routes.rbpara edição, uso nanoou seu editor favorito:

• nano config/routes.rb

O arquivo ficará assim:

Rails.application.routes.draw do
  resources :sharks
  # For details on the DSL available within this file, see http://guides.rubyonrails.org/routing.html
end

Sem definir algo mais específico, a visualização padrão na página de boas-vindas do Rails http://localhost:3000ou será a página de boas-vindas do Rails.http://your_server_ip:3000

Para mapear a visualização raiz do aplicativo para a indexvisualização do controlador de tubarões, você precisará adicionar a seguinte linha ao arquivo:

Rails.application.routes.draw do
  resources :sharks

  root 'sharks#index' 
  # For details on the DSL available within this file, see http://guides.rubyonrails.org/routing.html
end

Agora, quando os usuários navegarem para a raiz do aplicativo, eles verão uma lista completa de tubarões e terão a oportunidade de criar uma nova entrada de tubarão, examinar as entradas existentes e editar ou excluir as entradas fornecidas.

Salve o arquivo e saia do seu editor quando terminar de editar. Se você costumava nanoeditar o arquivo, pode fazê-lo pressionando CTRL+X, Ye depoisENTER

Agora você pode executar suas migrações com o seguinte comando:

• rails db:migrate

Você verá a saída confirmando a migração.

Inicie seu servidor Rails mais uma vez. Se você estiver trabalhando localmente, digite:

• rails s

Em um servidor de desenvolvimento, digite:

• rails s --binding=your_server_ip

Navegue para localhost:3000se você estiver trabalhando localmente ou se estiver trabalhando em um servidor de desenvolvimento.http://your_server_ip:3000

A página de destino do seu aplicativo ficará assim:

Para criar um novo tubarão, clique no link Novo tubarão na parte inferior da página, que o levará à sharks/newrota:

Vamos adicionar algumas informações de demonstração para testar nosso aplicativo. Insira "Great White" no campo Name e "Scary" no campo Facts :

Clique no botão Criar para criar o tubarão.

Isso o direcionará para a showrota, que, graças ao before_actionfiltro, é definida com o set_sharkmétodo, que captura ido tubarão que acabamos de criar:

class SharksController < ApplicationController
  before_action :set_shark, only: [:show, :edit, :update, :destroy]

  . . . 

  def show
  end

  . . . 

  private
    # Use callbacks to share common setup or constraints between actions.
    def set_shark
      @shark = Shark.find(params[:id])
    end
  . . .

Você pode testar a função de edição agora clicando em Editar na sua entrada de tubarão. Isso o levará à editrota do tubarão:

Altere o factssobre o Great White para ler “Large” em vez de “Scary” e clique em Update Shark . Isso o levará de volta à showrota:

Por fim, clicar em Voltar levará você à sua indexexibição atualizada :

Agora que você testou a funcionalidade básica do seu aplicativo, você pode adicionar algumas validações e verificações de segurança para tornar tudo mais seguro.

Etapa 5 - Adicionando validações

Seu aplicativo shark pode aceitar informações dos usuários, mas imagine um caso em que um usuário tente criar um tubarão sem adicionar fatos a ele ou crie uma entrada para um tubarão que já esteja no banco de dados. Você pode criar mecanismos para verificar os dados antes que eles sejam inseridos no banco de dados adicionando validações aos seus modelos. Como a lógica do seu aplicativo está localizada em seus modelos, validar a entrada de dados aqui faz mais sentido do que fazê-lo em outro lugar no aplicativo.

Observe que não abordaremos escrever testes de validação neste tutorial, mas você pode descobrir mais sobre testes consultando a documentação do Rails .

Se você ainda não parou o servidor, faça isso digitando CTRL+C.

Abra seu shark.rbarquivo de modelo:

• nano app/models/shark.rb

Atualmente, o arquivo nos diz que a Sharkclasse herda de ApplicationRecord, que por sua vez herda de ActiveRecord::Base:

class Shark < ApplicationRecord
end

Vamos primeiro adicionar algumas validações ao nosso namecampo para confirmar que o campo foi preenchido e que a entrada é exclusiva, impedindo entradas duplicadas:

class Shark < ApplicationRecord
  validates :name, presence: true, uniqueness: true
end

Em seguida, adicione uma validação para o factscampo para garantir que ele também seja preenchido:

class Shark < ApplicationRecord
  validates :name, presence: true, uniqueness: true
  validates :facts, presence: true
end

Aqui estamos menos preocupados com a singularidade dos fatos, desde que eles estejam associados a entradas únicas de tubarões.

Salve e feche o arquivo quando terminar.

Inicie o servidor novamente com rails sou , dependendo de você estar trabalhando localmente ou com um servidor de desenvolvimento.rails s --binding=your_server_ip

Navegue até a raiz do seu aplicativo em http://localhost:3000ou .http://your_server_ip:3000

Clique em New Shark . No formulário, adicione "Great White" ao campo Name e "Big Teeth" ao campo Facts e clique em Create Shark . Você deve ver o seguinte aviso:

Agora, vamos ver se podemos verificar nossa outra validação. Clique em Voltar para retornar à página inicial e, em seguida, em Novo tubarão novamente. No novo formulário, digite "Tiger Shark" no campo Nome e deixe fatos em branco. Clicar em Criar tubarão acionará o seguinte aviso:

Com essas alterações, seu aplicativo possui algumas validações para garantir consistência nos dados salvos no banco de dados. Agora você pode voltar sua atenção para os usuários do seu aplicativo e definir quem pode modificar os dados do aplicativo.

Etapa 6 - Adicionando autenticação

Com as validações em vigor, temos algumas garantias sobre os dados que estão sendo salvos no banco de dados. Mas e os usuários? Se não quisermos que todos e quaisquer usuários sejam adicionados ao banco de dados, devemos adicionar algumas medidas de autenticação para garantir que apenas usuários permitidos possam adicionar tubarões. Para fazer isso, usaremos o http_basic_authenticate_withmétodo , que nos permitirá criar uma combinação de nome de usuário e senha para autenticar usuários.

Existem várias maneiras de autenticar usuários com o Rails, incluindo o trabalho com o bcryptou devisegems. Por enquanto, no entanto, adicionaremos um método ao nosso controlador de aplicativo que será aplicado às ações em nosso aplicativo. Isso será útil se adicionarmos mais controladores ao aplicativo no futuro.

Pare seu servidor novamente com CTRL+C.

Abra o arquivo que define seu ApplicationController:

• nano app/controllers/application_controller.rb

Dentro, você verá a definição para a ApplicationControllerclasse, da qual os outros controladores em seu aplicativo herdam:

class ApplicationController < ActionController::Base
end

Para autenticar usuários, usaremos um nome de usuário e uma senha codificados no http_basic_authenticate_withmétodo. Adicione o seguinte código ao arquivo:

class ApplicationController < ActionController::Base
  http_basic_authenticate_with name: 'sammy', password: 'shark', except: [:index, :show]
end

Além de fornecer o nome de usuário e a senha aqui, também restringimos a autenticação, especificando as rotas nas quais isso não deveria ser necessário: indexe show. Outra maneira de conseguir isso seria escrever only: [:create, :update, :destroy]. Dessa forma, todos os usuários poderão examinar todos os tubarões e ler fatos sobre determinados tubarões. No entanto, quando se trata de modificar o conteúdo do site, os usuários precisam provar que têm acesso.

Em uma configuração mais robusta, você não deseja codificar valores dessa maneira, mas, para fins de demonstração, isso permitirá que você veja como pode incluir a autenticação para as rotas do seu aplicativo. Ele também permite que você veja como o Rails armazena dados da sessão por padrão em cookies: depois que você se autentica em uma ação especificada, não é necessário se autenticar novamente na mesma sessão.

Salve e feche app/controllers/application_controller.rbquando terminar de editar. Agora você pode testar a autenticação em ação.

Inicie o servidor com ou rails sou navegue para seu aplicativo em ou .rails s --binding=your_server_iphttp://localhost:3000http://your_server_ip:3000

Na página de destino, clique no botão Novo tubarão . Isso acionará a seguinte janela de autenticação:

Se você digitar a combinação de nome de usuário e senha adicionada app/controllers/application_controller.rb, poderá criar com segurança um novo tubarão.

Agora você tem um aplicativo de tubarão em funcionamento, completo com validações de dados e um esquema básico de autenticação.

Conclusão

O aplicativo Rails que você criou neste tutorial é um ponto de partida que você pode usar para desenvolvimento adicional. Se você estiver interessado em explorar o ecossistema do Rails, a documentação do projeto é um ótimo lugar para começar.

Você também pode aprender mais sobre como adicionar recursos aninhados ao seu projeto, lendo Como criar recursos aninhados para um aplicativo Ruby on Rails , que mostrará como criar os modelos e rotas do aplicativo.

Além disso, você pode querer explorar como configurar um front-end mais robusto para o seu projeto com uma estrutura como o React . Como configurar um projeto Ruby on Rails com um front-end do React oferece orientações sobre como fazer isso.