Introdução (Rails 7)

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 7.1

Criar novo aplicativo

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

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

Passamos --skip-active-record para solicitar que o ActiveRecord não seja adicionado como uma dependência, porque usaremos o Mongoid em vez disso.

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

Configurar o 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. Gerar a configuração padrão do Mongoid:

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.

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

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

Executar aplicativo

Agora você pode iniciar o servidor de aplicativos executando:

bin/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
    include Mongoid::Timestamps
    field :title, type: String
    field :body, type: String
    has_many :comments, dependent: :destroy
  end

Abra 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 app/views/comments/_form.html.erb e altere o tipo de campo para :message de text_field para text_area, assim 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 %>

Em seguida, substitua app/view/comments/_comment.html.erb pelo seguinte conteúdo:

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

Você agora já pode comentar nas postagens

Dependencies

Primeiro, o gem mongoid precisará ser adicionado ao seu Gemfile.

  gem 'mongoid'

Se o Mongoid for o único adaptador de banco de dados, remova ou comente quaisquer bibliotecas RDBMS como sqlite ou pg mencionadas no Gemfile.

Instale as dependências do gem:

bundle install

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 Configurar para MongoDB autogerenciado e Configurar para MongoDB Atlas para decidir como você deseja distribuir o MongoDB e ajustar a configuração Mongoid (config/mongoid.yml) para corresponder.

Frameworks carregadas

Examine config/application.rb. Se estiver exigindo todos os componentes do Rails via require 'rails/all', altere-o para exigir estruturas individuais. Para verificar o conteúdo de rails/all em sua versão, consulte o repositório do Github:

# Remove or comment out
#require "rails/all"
# Add the following instead of "rails/all":
require "rails"
# require "active_record/railtie" rescue LoadError
# require "active_storage/engine" rescue LoadError
require "action_controller/railtie" rescue LoadError
require "action_view/railtie" rescue LoadError
require "action_mailer/railtie" rescue LoadError
require "active_job/railtie" rescue LoadError
require "action_cable/engine" rescue LoadError
# require "action_mailbox/engine" rescue LoadError
# require "action_text/engine" rescue LoadError
require "rails/test_unit/railtie" rescue LoadError

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.

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.