Primeiros passos (Rails 6)

Instalar rails

Usaremos um gerador Rails para criar o esqueleto do aplicativo. Para fazer isso, a primeira etapa é instalar a joia rails:

gem install rails -v '~> 6.0'

Criar novo aplicativo

Utilize o comando rails para criar a estrutura básica do aplicativo, conforme mostrado:

rails new blog --skip-active-record --skip-bundle
cd blog

Could not find gem 'puma (~> 3.11)' in any of the gem sources listed in your Gemfile.
Run `bundle install` to install missing gems.

Passamos --skip-active-record para solicitar que o ActiveRecord não seja adicionado como uma dependência, porque usaremos o Mongoid em vez disso. Além disso, passamos --skip-bundle porque modificaremos o Gemfile para adicionar a dependência mongoid .

Se você pretende testar seu aplicação com RSpec, você pode instruir o gerador a omitir a configuração padrão de teste do Rails passando pelas opções --skip-test e --skip-system-test :

rails new blog --skip-bundle --skip-active-record --skip-test --skip-system-test
cd blog

Criar repositório Git

Embora não seja necessário, recomendamos criar um repositório Git para seu aplicativo:

git init .
git add .
git commit

Confirme suas alterações conforme segue este tutorial.

Adicionar Mongoid

1. Modifique o Gemfile para adicionar uma referência ao mongoid joia:

  gem 'mongoid'

2. Instale as dependências do gem:

bundle install

3. Gere a configuração Mongoide padrão:

bin/rails g mongoid:config

Este gerador criará o arquivo de configuração config/mongoid.yml (usado para configurar a conexão com a implantação MongoDB) e o arquivo inicializador config/initializers/mongoid.rb (que pode ser usado para outras configurações relacionadas ao Mongoid). Observe que, como não estamos usando o ActiveRecord, não teremos um arquivo database.yml.

Execute o MongoDB localmente

A configuração criada na etapa anterior é adequada quando um servidor MongoDB está sendo executado localmente. Se você ainda não tiver um servidor MongoDB local, baixe e instale o MongoDB.

Embora o mongoid.yml gerado funcione sem modificações, recomendamos reduzir o tempo limite de seleção do servidor para desenvolvimento. Com essa alteração, as linhas não comentadas de mongoid.yml deverão ficar assim:

development:
  clients:
    default:
      database: blog_development
      hosts:
        - localhost:27017
      options:
        server_selection_timeout: 1

Usar o MongoDB Atlas

Em vez de baixar, instalar e executar o MongoDB localmente, você pode criar uma conta gratuita do MongoDB Atlas e criar um cluster MongoDB gratuito no Atlas. Após a criação do cluster, siga as instruções em conectar à página do cluster para obter o URI. Use o driver Ruby 2.5 ou o formato posterior .

Cole o URI no arquivo config/mongoid.yml e comente os hosts definidos. Recomendamos configurar o tempo limite de seleção do servidor para cinco segundos para o ambiente de desenvolvimento ao utilizar o Atlas.

O conteúdo não comentado de config/mongoid.yml deve ficar assim:

development:
  clients:
    default:
      uri: mongodb+srv://user:pass@yourcluster.mongodb.net/blog_development?retryWrites=true&w=majority
      options:
        server_selection_timeout: 5

Outras dependências do Rails

Se este for o primeiro aplicação Rails que você está criando, talvez seja necessário instalar o Node.js no seu computador. Isso pode ser feito por meio dos pacotes do seu sistema operacional ou baixando um binário.

Em seguida, se você não tiver o Yarn instalado, siga as instruções de instalação.

Por fim, instale o webpacker:

rails webpacker:install

Executar aplicativo

Agora você pode iniciar o servidor de aplicativos executando:

rails s

Acesse o aplicativo navegando até localhost:3000.

Adicionar publicações

Usando estrutura padrão do Rails, o Mongoid pode gerar o modelo, o controlador e os arquivos de visualização necessários para nosso blog, para que possamos começar rapidamente a criar postagens no blog:

bin/rails g scaffold Post title:string body:text

Navegue até localhost:3000/posts para criar publicações e ver as publicações que já foram criadas.

Adicionar comentários

Para deixar nosso aplicativo mais interativo, vamos permitir que os usuários adicionem comentários às publicações.

Criar o modelo Comment:

bin/rails g scaffold Comment name:string message:string post:belongs_to

Abra o arquivo de modelo Post, app/models/post.rb e adicione uma associação has_many para os comentários:

  class Post
    include Mongoid::Document
    field :title, type: String
    field :body, type: String
    has_many :comments, dependent: :destroy
  end

  class Comment
    include Mongoid::Document
    field :name, type: String
    field :message, type: String
    belongs_to :post
  end

Abra o arquivo de visualização da publicação, app/views/posts/show.html.erb, e adicione uma seção que renderiza os comentários existentes e solicita que você deixe um novo comentário:

<section class="section comments">
  <div class="container">
    <h2 class="subtitle is-5">
      <strong><%= @post.comments.count %></strong> Comments
    </h2>
    <%= render @post.comments %>
    <div class="comment-form">
      <hr />
      <h3 class="subtitle is-3">Leave a reply</h3>
      <%= render partial: 'comments/form', locals: { comment: @post.comments.build } %>
    </div>
  </div>
</section>

Abra o arquivo de formulário de comentário e altere o tipo de campo para :message de text_field para text_area, bem como o tipo de campo para :post_id de text_field para hidden_field. O resultado deve ficar assim:

<%= form_with(model: comment, local: true) do |form| %>
  <% if comment.errors.any? %>
    <div id="error_explanation">
      <h2><%= pluralize(comment.errors.count, "error") %> prohibited this comment from being saved:</h2>
      <ul>
        <% comment.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 :message %>
    <%= form.text_area :message %>
  </div>
  <div class="field">
    <%= form.hidden_field :post_id %>
  </div>
  <div class="actions">
    <%= form.submit %>
  </div>
<% end %>

Crie uma parcial para a visualização de comentário, app/views/comments/_comment.html.erb com o seguinte conteúdo:

<p>
  <strong><%= comment.name %>:</strong>
  <%= comment.message %>
<br>
<%= link_to 'Delete', [comment],
  method: :delete,
  class: "button is-danger",
  data: { confirm: 'Are you sure?' } %>
</p>

Você agora já pode comentar nas postagens

Dependencies

Remova ou comente quaisquer bibliotecas RDBMS como sqlite, pg etc. mencionadas em Gemfile e adicione mongoid:

  gem 'mongoid'

Instale as dependências do gem:

bundle install

Frameworks carregadas

Examine config/application.rb. Se estiver exigindo todos os componentes do Rails via require 'rails/all', altere-o para exigir estruturas individuais:

# Remove or comment out
#require "rails/all"
# Add this require instead of "rails/all":
require "rails"
# Pick the frameworks you want:
require "active_model/railtie"
require "active_job/railtie"
require "action_controller/railtie"
require "action_mailer/railtie"
# require "action_mailbox/engine"
# require "action_text/engine"
require "action_view/railtie"
require "action_cable/engine"
require "sprockets/railtie"
require "rails/test_unit/railtie"
# Remove or comment out ActiveRecord and ActiveStorage:
# require "active_record/railtie"
# require "active_storage/engine"

Configuração ActiveRecord

Revise todos os arquivos de configuração (config/application.rb, config/environments/{development,production.test}.rb) e remova ou comente quaisquer referências a config.active_record e config.active_storage.

Pare a primavera

Se o seu aplicativo estiver usando o Spring, que é o padrão no Rails 6, o Spring deverá ser interrompido após a alteração de dependências ou configuração.

./bin/spring stop

Configuração do Mongoide

Gere a configuração Mongoide padrão:

bin/rails g mongoid:config

Este gerador criará o arquivo de configuração config/mongoid.yml (usado para configurar a conexão com a implantação MongoDB) e o arquivo inicializador config/initializers/mongoid.rb (que pode ser usado para outras configurações relacionadas ao Mongoid). Em geral, recomenda-se usar mongoid.yml para todas as configurações do Mongoid.

Revise as seções Executar o MongoDB localmente e Usar o MongoDB Atlas para decidir como você deseja distribuir o MongoDB e ajustar a configuração do Mongoide (config/mongoid.yml) para corresponder.

Ajustar modelos

Se o seu aplicativo já tiver modelos, estes terão de ser alterados ao migrar do ActiveRecord para o Mongoid.

Os modelos ActiveRecord derivam do ApplicationRecord e não têm definições de coluna. Os modelos Mongoid geralmente não têm superclasse, mas devem incluir Mongoid::Document, e geralmente definem os campos explicitamente (mas campos dinâmicos também podem ser usados em vez de definições de campo explícitas).

Por exemplo, um modelo Post básico pode ter a seguinte aparência no ActiveRecord:

class Post < ApplicationRecord
  has_many :comments, dependent: :destroy
end

O mesmo modelo pode ter a seguinte aparência no Mongoid:

class Post
  include Mongoid::Document
  field :title, type: String
  field :body, type: String
  has_many :comments, dependent: :destroy
end

Ou assim com campos dinâmicos:

class Post
  include Mongoid::Document
  include Mongoid::Attributes::Dynamic
  has_many :comments, dependent: :destroy
end

O Mongoid não utiliza migrações do ActiveRecord, pois o MongoDB não exige que um esquema seja definido antes de armazenar dados.

Migração de dados

Se você já tiver dados em um banco de dados relacional que gostaria de transferir para o MongoDB, será necessário realizar uma migração de dados. Conforme observado acima, não é necessária nenhuma migração de esquema porque o MongoDB não exige um esquema predefinido para armazenar os dados.

As ferramentas de migração geralmente são específicas para os dados que estão sendo migrados porque, embora o Mongoid ofereça suporte a um superconjunto de associações ActiveRecord, a maneira pela qual as referências daquele modelo são armazenadas em coleções difere entre o Mongoid e o ActiveRecord. Dito isso, o MongoDB tem alguns recursos sobre a migração de um RDBMS para o MongoDB, como o Guia de migração do RDBMS para o MongoDB e o Guia de modernização.

API do Rails

O processo para criar um aplicativo de API Rails com Mongoid é o mesmo usado para criar um aplicativo regular, e a única alteração é o parâmetro --api para rails new. Migrar um aplicativo de API Rails para Mongoid segue o mesmo processo descrito acima para aplicativos Rails regulares.

Um aplicativo completo da API Rails semelhante ao descrito neste tutorial pode ser encontrado no repositório GitHub mongoid-demo.