Forem: Dominique Morem

Enums no Rails 8: anatomia e uma aplicação prática

Dominique Morem — Sat, 03 Jan 2026 17:43:12 +0000

Introdução

Por uma questão de Legibilidade e Manutenibilidade escolherei trabalhar com enums do tipo string e não sendo do tipo integer, que é o mais comum. Michał Rudzki fez um artigo muito bom com um comparativo de perfomance, bem como indicando os pontos positivos e negativos entre os dois.

Rudzki deu dois grandes motivos para optar pelo enum com o tipo string: em enums baseados em string, você pode ler os dados do registro diretamente do banco de dados (o que favorece a legibilidade), e, você pode adicionar um enum facilmente a uma coluna existente, sem precisar se preocupar com possível perda de dados se utilizar o tipo string ( o que contribui na manutenibilidade).

Dito isso, vamos aplicação do enum. Antes de começarmos, pressuponho que você já tenha feita e migrada a tabela na qual deseja colocar o seu enum. A tabela - não só ela mas todo o MVC envolvido nos Usuários - que usaremos aqui foi criada da seguinte forma e com os seguintes campos:

rails g scaffold User name email birthdate:date

Depois disso eu dei o rails db:migrate (já tinha criado o banco de dados previamente) e então partimos para o ponto de colocação do enum que veremos à seguir...

1 - Gere a MIGRATION

rails g migration AddMaritalStatusToUsers marital_status:string:index

Onde:

AddMaritalStatusToUsers - É o comando que indica pro Rails que você quer colocar uma nova coluna em uma determinada entidade do seu banco de dados. No seu caso será: AddNomeDoSeuEnumToNomeDaSuaTabela.
marital_status - É o nome da coluna a ser adicionada a tabela Users
string - O tipo de dado que essa coluna receberá
index - Cria um índice para a coluna, o índice é uma estrutura auxiliar do banco que acelera buscas.

2 - Edite a MIGRATION

Acrescente o default: "solteiro":

Isso vai colocar por padrão (se o usuário não marcar nada) o enum como: "solteiro". Todos os campos que estão em branco ficarão com esse status automaticamente.

Execute no prompt:

rails db:migrate

Explicando melhor as linhas da migration

Sobre o add_column:

Sobre o add_index:

3 - Anatomia do enum no MODEL

Vamos configurar agora o nosso enum no model.

Bem, a "anatomia" do Enum do tipo string no Rails 8 é tipo essa:

enum :nome_do_seu_enum, {
chave1: "valor1",
chave2: "valor2,
chave3: "valor3"
}

As bases para se chegar a essa 'anatomia' estão aqui (no artigo do Michał Rudzki) e aqui (na documentação do Rails 8).

Aplicando o enum ao nosso cado aqui vai ficar assim:

enum :marital_status, {
    solteiro: "solteiro",
    casado: "casado",
    divorciado: "divorciado",
    viuvo: "viuvo",
    uniao_estavel: "uniao_estavel"
  }

Há algo interessante que podemos aplicar a esse enum também para facilitar a nossa vida... o "prefix: true". Mas para quê ele serve?

3.1 - O que o "prefix: true" faz?

Ele adiciona um prefixo com o nome do atributo aos métodos gerados pelo enum.

Sem prefixo, o Rails criaria métodos assim:

customer.solteiro?
customer.casado?
customer.viuvo!

Com prefix: true, eles viram:

customer.marital_status_solteiro?
customer.marital_status_casado?
customer.marital_status_viuvo!

Com prefix: true:

tudo fica explícito
mais legível em projetos grandes
menos bugs “fantasma”

3.2 - Adicionando validações

Vamos acrescentar as seguintes validações ao nosso enum:

validates :marital_status, presence: true, inclusion: { in: marital_statuses.keys }

Onde cada validação diz o seguinte:

validates - Rails valide para mim a seguinte estrutura
:marital_status - A coluna a ser validada
presence: true - Torna o preenchimento daquela coluna obrigatório, ou seja, não pode ser enviado ao banco de dados como nulo (nil), não pode ir em branco.
inclusion: - Valida que o valor do atributo está dentro de uma lista específica de valores permitidos.
marital_statuses.keys - Retorna um array com as chaves que poderão ser aceitas: ["solteiro", "casado", "divorciado", "viuvo", "uniao_estavel"].

Ou seja, o "presence" impede valores vazios e o "inclusion" impede valores inválidos, que não correspondam aos valores previamente passados.

4 - Permita a coluna no CONTROLLER

No Rails existe um conceito chamado: Strong Parameters.

Esse Strong Parameters quer dizer basicamente: Nenhum dado vindo do usuário entra no model se o programador do projeto não permitir explicitamente (isso por uma questão de segurança).

Ou seja, se você não for ao método "user_params" e não colocar o "marital_status" explicitamente lá, o Rails simplesmente vai ignorar esse campo e seguir pleníssimo sem enviar essa informação para o banco da dados.

Por isso, vamos acrescentar a coluna 'marital_status' ao nosso método 'user_params':

5 - Trabalhando com o enum nas VIEWs

Vamos precisar mexer em duas partials (fragmentos de view reutilizáveis):

Uma que diz respeito ao formulário que será aplicado ao usuário (_form.html.erb)
Outra que diz respeito a exibição daquele usuário depois de cadastrado (_user.html.erb)

Prensando primeiro no select (menu) que faremos para o usuário escolher o seu status civil no formulário...

5.1 - Lidando com o enum no _form.html.erb

No enum atualmente temos os seguintes valores para os estados civis:

enum :marital_status, {
    solteiro: "solteiro",
    casado: "casado",
    divorciado: "divorciado",
    viuvo: "viuvo",
    uniao_estavel: "uniao_estavel"
  }, prefix: true

Como podem ver, teremos um sério desconforto caso esses valores forem exibidos no menu para o usuário dessa forma. Isso porque:

União Estável possui espaço e acentos
Viúvo também possui acento
O ideal é que os status civis viessem com letra maiúscula
Os usuários serão de ambos os gêneros, logo, o ideal seria colocar a partícula (a) na intenção de contemplar a ambos.

Para resolver isso ao renderizar a partial sair com os valores bonitinhos no menu.

5.1.1 - Criando a constante que vai receber o hash com a tradução

Façamos o seguinte, vamos ao model user.rb:

app > models : user.rb

Uma vez que estejamos no model, vamos criar uma constante que irá conter um hash (chave/valor) de dados contendo as chaves que estão do jeitinho lá do enum e os valores traduzidos:

MARITAL_STATUS_TRANSLATIONS = {
    "solteiro" => "Solteiro(a)",
    "casado" => "Casado(a)",
    "divorciado" => "Divorciado(a)",
    "viuvo" => "Viúvo(a)",
    "uniao_estavel" => "União Estável"
  }

Pronto agora já temos uma 'tradução' com as perfumarias que queremos exibir!

Ok, mas como vamos aplicar isso a partial?

5.1.2 - Entendendo o helper options_for_select

Vamos a documentação

Para montar o nosso select (menu com os enums) vamos utilizar o helper options_for_select (ele é do tipo Form Options Helper). Vamos dar uma olhadinha na documentação dele:

Ele aceita diversas opções de entrada: hash, array e enumerável. Vamos utilizar essa primeira onde ele aceita receber arrays com chave/valor. Repare que:

O Primeiro elemento - É o texto que o usuário vê (ex: "Dollar")
O Segundo elemento - É o valor a ser salvo no banco (ex: "\$")

Então o array que vamos gerar precisará ter os primeiros elementos como sendo o valores bonitinhos e os segundos elementos os valores corretos do enum que são os que de fato vão para o banco. Vamos lá criá-lo entao...

5.1.3 - Criando método no model que vai nos ajudar na view

Vamos ao user.rb (app > models : user.rb) e neste criaremos um método de classe - ou seja, um método que pertence à classe em si. Que não precisa criar um objeto, chama direto na classe - para facilitar a nossa vida na hora de montar o select lá na view e deixar o codigo da view mais limpo e independente:

def self.marital_status_to_select
    marital_statuses.keys.map { |values|
      [MARITAL_STATUS_TRANSLATIONS[values], values]
    }
end

Onde:

self. - indica que é um método de classe, não de instância
marital_statuses.keys - pega todas as chaves do enum como array: ["solteiro", "casado", "divorciado", "viuvo", "uniao_estavel"]
.map { |values| ... } - itera sobre cada valor
[MARITAL_STATUS_TRANSLATIONS[values], values] - cria um array com 2 elementos:
- Primeiro elemento: texto que o usuário vê (ex: "Solteiro(a)")
- Segundo elemento: valor salvo no banco (ex: "solteiro")

Com isso, teremos o seguinte retorno:

[
  ["Solteiro(a)", "solteiro"],
  ["Casado(a)", "casado"],
  ["Divorciado(a)", "divorciado"],
  ["Viúvo(a)", "viuvo"],
  ["União Estável", "uniao_estavel"]
]

Perfeito, agora vamos lá as views aplicá-lo a partial do formulário...

5.1.4 - Aplicando o método de classe na partial

<div>
    <%= form.label :marital_status, style: "display: block" %>
    <%= form.select :marital_status,
                    options_for_select(
                      User.marital_status_to_select
                    )
     %>
  </div>

5.1.5 - Deixando opção pré-selecionada em caso de edição

A partial _form.html.erb pode ser utilizada tanto no cadastro de um usuário novo como na edição de um usuário já existente.

Levando em consideração essa segunda possibilidade utilizaremos o form.object.marital_status. Ele é usado para pré-selecionar a opção correta no dropdown quando você está editando um usuário existente.

A coisa toda vai ficar assim:

<div>
    <%= form.label :marital_status, style: "display: block" %>
    <%= form.select :marital_status,
                    options_for_select(
                      User.marital_status_to_select,
                      form.object.marital_status
                    )
     %>
  </div>

5.2 - Lidando com o enum no _user.html.erb

Para além de dar a opções bonitinhas, bem legíveis e amigáveis lá para a pessoa na hora de marcar no select (menu) do formulário, devemos prover também ao usuário poder ver o seu status matrimonial de maneira linda e amigável depois que preencher e enviar o nosso formulário.

Para isso é que vamos mexer na partial _user.html.erb . Mas antes precisamos configurar algo no model dos usuários.

5.2.1 - Criando o método para a tradução no Model

Vamos até o user.rb (Ctrl + p para fazer a busca rápida).

Uma vez no model criaremos neste um método de instância (ou seja, que pertence a um objeto específico (uma instância da classe) para fazer essa tradução bonitinha pro usuário na hora que ele for ver o cadastro que acabou de criar.

Onde:

marital_status - Esse marital_status é o valor do atributo da instância atual do User. Ou seja, ele vem da coluna marital_status e não do enum.
MARITAL_STATUS_TRANSLATIONS[...] - Usa esse valor como chave no hash de traduções

Um exemplo do que acontece ao aplicar esse método:

marital_status retorna "solteiro"
MARITAL_STATUS_TRANSLATIONS["solteiro"] busca no hash
Retorna "Solteiro(a)"

5.2.2 - Modificando na partial _user.html.erb

Uma vez que você esteja na partial, basta aplicar o método ao objeto de user e vòi la vai ficar com o textinho na tela!!

<div>
    <strong>Marital Status:</strong>
    <%= user.marital_status_humanized %>
</div>

6 - Possibilidades de melhoria

Obviamente o conteúdo que cá está não esgota a temática dos enums no Rails, e nem pretende fazê-lo! Existem inúmeros tópicos que poderiam ser debatidos ainda nos enums, como por exemplo:

A aplicação do I18n para internacionalização e adaptação a outros idiomas.
A remoção do 'default' da migration podendo, consequentemente, colocar um placeholder no select
Falar de scopes
Entre outros temas...

Colocando Favicon na sua Aplicação Ruby/Rails

Dominique Morem — Mon, 13 Oct 2025 01:54:16 +0000

Fala pessoal! Hoje vamos aprender a colocar um Favicon em nossa aplicação web. Para quem não sabe, um favicon (junção de favorite + icon) é um pequeno ícone gráfico associado a um site ou página da web, normalmente ele fica na aba do navegador, ao lado do título da página. Pois bem, é isso que vamos colocar!

Então, se você se interessou, vem comigo!

1. Pegue o logotipo e traga para dentro do projeto

Pegue a imagem do logotipo que deseja inserir na aba da sua aplicação nomeie-a como 'favicon.png' - o Rails aceita tanto no formato .png, quanto no .ico, talvez aceite .svg também mas eu nunca testei para saber - e arraste-a para dentro da pasta 'Images'.

Essa pasta fica no seguinte caminho dentro da sua aplicação:

app > assets > images

Para ficar melhor de ver:

2. Faça os devidos ajustes no arquivo application.html.erb

Uma vez que a imagem do logotipo esteja no projeto você vai até o arquivo application.html.erb.

Ele fica normalmente em:

app > views > layouts

Bem aqui ó:

Nesse arquivo bem depois das metatags você vai:

2.1 - Remover esse trecho HTML aqui

2.2 - Inserir a seguinte tag depois das metatags

<%= favicon_link_tag 'favicon.png' %>

2.3 - O antes e depois

ANTES

DEPOIS

3 - Limpando o cache e reiniciando o servidor

Antes de darmos seguimento de apresentação do favicon, precisamos garantir que o cache do seu navegador está limpo pois isso pode dar problema na hora de mostrar o icone na aba.

Dê um:

Ctrl + Shift + Delete

Limpe o seu cache e depois prosseguimos.

Pois bem, agora para fechar com chave de ouro devemos restartar o nosso servidor no Rails.

Ctrl + C - Para parar o servidor

bin/dev

No terminal para restartá-lo.

Abra o localhost e lá vai estar ele!

O seu favicon lindo e pleno!

Espero ter ajudado.

Abraço à todos,

Dominique.

Configuração setup básico p/ projetos Ruby/Rails - utilizando o WSL 2

Dominique Morem — Wed, 08 Oct 2025 15:44:48 +0000

O que será visto durante esta postagem:

Instalação do Windows Terminal.
Instalação do WSL 2.
Instalação e configuração do Ubuntu.
Instalação do Git.
Instalação do PostgreSQL.
Instalação e configuração do VSCode.
Instalação do Rails.

Observação inicial

Pessoal, alguns dos passos apresentados neste guia podem ser acompanhados em vídeo no canal Vídeos de TI no Youtube, que também traz tutoriais práticos e explicativos sobre a temática aqui abordada. Para quem aprende bem por meio de audiovisual, fica a dica. Alguns dos exemplos de conteúdos aqui presentes que vocês também encontrarão por lá são os comandos básicos do terminal Ubuntu (video) e o processo de instalação do RVM (video).

Assim, você poderá optar por seguir via texto por aqui, ou por acompanhar visualmente pelo canal, o que for mais confortável a sua pessoa.

1 - Começando pela instalação do Windows Terminal

Este passo é opcional

O Windows Terminal é uma interface moderna para usar vários shells (CMD, PowerShell, WSL, etc). Apesar de ser opcional, ele é muito recomendado pois facilita quando formos utilizar o WSL 2.

Para instalá-lo é muito simples.

1.1 - Vá até a Microsoft Store

1.2 - Na Microsoft Store busque por ‘Windows Terminal’

E clique nessa opção do menu:

1.3 - Clique em 'Abrir'

Pronto! Já temos o Windows Terminal instalado!

2 - Instalando o WSL 2

O que é o WSL 2 e por que instalá-lo?

WSL 2 (Windows Subsystem for Linux 2) é uma tecnologia da Microsoft que permite rodar um ambiente Linux completo dentro do Windows, de maneira leve e integrada.

Em vez de usar uma máquina virtual tradicional, o WSL 2 roda um kernel Linux real dentro do Windows - só que em segundo plano - permitindo executar comandos, ferramentas e aplicações Linux, como se você estivesse num Ubuntu ou Debian, contudo sem sair do Windows.

Por que o WSL 2 é importante no desenvolvimento em Ruby?

A maioria das aplicações Ruby (especialmente as do Rails) são desenvolvidas e implantadas em servidores Linux.
Usar WSL 2 faz com que seu ambiente local seja idêntico ao do servidor de produção — evitando aquele clássico “funcionava no meu Windows”.
Muitas gems Ruby dependem de bibliotecas nativas do Linux

2.1 - Checando a nossa versão do Windows

Por que checar a versão: É importante checar a versão do Windows antes de instalar o WSL 2 (Windows Subsystem for Linux 2) porque nem todas as versões do Windows suportam o WSL 2 ou suas funções mais recentes.

O WSL 2 requer recursos específicos do sistema operacional, como o subsistema de máquina virtual (Virtual Machine Platform), que só está presente a partir do Windows 10 ( versão 1903 - build 18362 ou superior) e do Windows 11 (em todas as versões).

Para checar a versão do SO vamos pressionar:

Na janela de execução que se abrir digite ‘winver’ e dê um ‘ok’.

O Windows lhe trará a versão que está em vigor na sua máquina.

Certifique-se de que é versão 10 ou alguma acima desta.

2.2 - Verificando se há atualizações a serem feitas

Antes de seguir com o processo, é importante verificar se há atualizações a fazer. Para isso:

Abra o menu iniciar e vá em ‘configurações’.

Vá em ‘Atualização e segurança’.

Verifique se há alguma atualização disponível, caso exista, instale-a.

2.3 - Ativando recursos

Agora vamos ativar alguns recursos do Windows que serão necessários à instalação do WSL 2. Vamos acessá-los.

No menu iniciar vá em ‘ativar ou desativar recursos Windows’.

2.3.1 - Subsistema do Windows para Linux

explicação: É o componente principal do WSL, ele cria a camada de compatibilidade que permite rodar binários Linux (ELF64) diretamente no Windows.

Na janela de opções que irá se abrir ative o ‘Subsistema do Windows para Linux'.

2.3.2 - Plataforma de Máquina Virtual

explicação: Ela fornece os recursos básicos de virtualização que o WSL 2 precisa para rodar um kernel Linux real. Ou seja, ela cria e gerencia pequenas máquinas virtuais leves, usadas pelo WSL 2 para executar o kernel Linux.

Ative também a opção ‘Plataforma de Máquina Virtual’.

2.3.3 - Plataforma do Hipervisor do Windows

explicação: É o conjunto de APIs que permite que o sistema operacional e aplicativos (como WSL 2 ou Docker) usem o Hyper-V — o hipervisor nativo do Windows. É interessante ativar, pois o kernel Linux do WSL 2 roda em uma VM gerenciada por esse hipervisor, que faz o isolamento entre o Windows e o Linux.

Ative adicionalmente a 'Plataforma do Hipervisor do Windows'

2.3.4 - Depois de marcar todas essas opções clique em ‘ok’

2.4 - Reiniciando a máquina para efetivar as mudanças

Depois de feito o carregamento dos recursos selecionados anteriormente, o Windows vai pedir para reiniciar a máquina, clique em ‘reiniciar agora’.

2.5 - Baixando o pacote

explicação: Nós já ativamos os componentes: Subsistema do Windows para Linux, Plataforma de Máquina Virtual e Plataforma do Hipervisor, ou seja, habilitamos o ambiente onde o WSL 2 vai rodar. Mas, ainda falta o kernel Linux propriamente dito — ou seja, “coração” do sistema. O Windows não vem com ele instalado por padrão, o que vamos fazer agora é baixar e instalar o pacote kernel Linux compilado pela Microsoft.

Reiniciada a nossa máquina, agora vamos ao navegador. Insira esta URL neste para baixar o WSL, posteriormente, dê um ‘Enter’:

https://wslstorestorage.blob.core.windows.net/wslblob/wsl_update_x64.msi

Depois de baixado, vamos executá-lo. Clique no arquivo baixado.

E depois clique em 'Executar'.

E instale o pacote.

2.6 - Definindo o WSL 2 como a versão padrão

Como o WSL possui duas versões, o WSL e o WSL 2, vamos dar um comando para definir o WSL 2 como a versão padrão para todas as novas distribuições Linux que você instalar no Windows.

Para definir isso, precisaremos dos 'poderes' de Administrador.

Portanto, vamos abrir o terminal ‘PowerShell’ e executá-lo como 'Administrador'.

No terminal ‘PowerShell’ vamos digitar/colar a seguinte opção e rodá-la:

wsl --set-default-version 2

3 - Instalação e configuração do Ubuntu

3.1 - Instalação do Ubuntu

Uma vez instalado o WSL 2, vamos finalmente poder instalar agora o Ubuntu.

Para isso, vá até a ‘Microsoft Store’.

Uma vez nesta, vamos procurar por ‘Ubuntu’ e instalar a versão 'Ubuntu 24.04.1 LTS'.

Clique em ‘Abrir’ para confirmar se a instalação foi concluída corretamente.

3.2 - Checando se o Ubuntu consta no Windows Terminal

Vamos checar se o Ubuntu foi certinho para o menu de terminais do Windows Terminal.

Para isso acesse o seu Windows Terminal.
Clique na setinha ao lado do ‘+’ na parte superior da janela.
No menu que aparecer clique na opção ‘Ubuntu’.

Como mostrado na figura à seguir:

Assim que abrir o terminal no Ubuntu ele vai mostrar essa mensagem na tela:

Aguarde uns segundinhos até ele terminar de instalar.

3.3 - Atribuindo Usuário e Senha ao Ubuntu

Depois disso ele vai pedir para você atribuir um nome para o novo usuário UNIX em:

Enter new UNIX username:

Insira o nome de usuário desejado.

E vai pedir uma senha - e uma repetição de senha - a esse novo usuário em:

New password:

e em

Retype new password:

Depois disso ele vai terminar de configurar o Ubuntu.

A tela vai ficar mais ou menos assim:

3.4 - Confirmando se as distros estão utilizando o WSL 2

Vá até o PowerShell, digite o comando:

wsl --list --verbose

O terminal vai mostrar algo assim - caso o WSL que está em uso seja o 2 - na coluna ‘Version’, nesta estará o número 2:

4 - APRENDENDO OS COMANDOS BÁSICOS NO TERMINAL DO UBUNTU

Alguns comandos são essenciais para uma boa navegação em terminais do Ubuntu. Aqui traremos alguns, vale a pena revisar:

pwd — Exibe o caminho completo da pasta onde você está.
ls — Lista arquivos e pastas.
cd Documentos - Entra na pasta Documentos.
cd .. - volta uma pasta.
cd ~ - volta para o diretório pessoal.(home)
mkdir projetos — Cria uma nova pasta.
rm -r pasta - apaga uma pasta e seu conteúdo.
cp arquivo.txt backup.txt - copia um arquivo.
cp -r pasta1 pasta2 - copia uma pasta com tudo dentro.
cat arquivo.txt - — Exibe o conteúdo de um arquivo.

O link para a videoaula é esse:

5 - COMANDOS ESSENCIAIS ANTES DAS INSTALAÇÕES

Se você acabou de instalar o Ubuntu via WSL 2 ou precisa instalar um novo programa, é bom começar com:

sudo apt update

E depois, se quiser aplicar as atualizações de fato dando um:

sudo apt upgrade

explicação: Porque dar esses comandos antes de começar as instalações? Rodar ambos os comandos antes de instalar qualquer pacote no WSL 2 é uma prática essencial por motivos técnicos e de segurança. Quando você instala o Ubuntu no WSL 2, ele vem com uma lista de pacotes desatualizada.
Se você não rodar sudo apt update, o sistema pode: não encontrar o Git (ou outro pacote), instalar versões antigas, ou gerar erros de dependência ao instalar.
Já o ‘sudo apt upgrade’ vai atualizar os pacotes que já estão no sistema, isso é importante para: corrigir bugs e falhas de segurança, garantir que tudo esteja compatível com os pacotes novos que serão instalados (como o Git).

6 - INSTALAÇÃO DO GIT

Vá ao Windows Terminal (no Ubuntu) e dê o comando para atualizar a lista de pacotes disponíveis nos repositórios.

sudo apt update

Depois dê o comando para instalar as atualizações disponíveis dos pacotes listados

sudo apt upgrade

Se ele perguntar se quer continuar a instalação aperte ‘y’ para ‘yes’ se ele perguntar:

Do you want to continue? [Y/n]

Ok, agora que tomamos medidas seguras, vamos instalar o GIT de fato.

Para isso utilizaremos o comando:

sudo apt install git

Para checar se o GIT foi de fato instalado podemos dar os seguintes comandos (de mesma função):

git -v

git --version

Pronto, agora já temos o Git instalado!

7 - INSTALAÇÃO DO RUBY

Nós vamos instalar a nossa primeira versão do Ruby e todas as demais versões que quisermos utilizar depois de uma mesma maneira: Ruby Version Manager(RVM), ou seja, via Gerenciador de Versões do Ruby. Usa-se essa forma pois é bem mais eficiente do que as demais e mais fácil de gerenciar também.

Para isso, vamos lá:

Abra o Windows Terminal.
Dê os dois comandos de praxe que sempre damos antes de instalar qualquer coisa:

sudo apt update

sudo apt upgrade

Vamos ao site oficial do RVM (Ruby Version Manager), na parte de instalação.
Copie a chave GPG que estiver lá e cole no seu terminal.

A do nosso caso aqui é essa:

gpg --keyserver keyserver.ubuntu.com --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3 7D2BAF1CF37B13E2069D6956105BD0E739499BDB

Verifique que ele importou as chaves.

Importadas com sucesso. Vamos ao próximo passo.

Retorne ao site do RVM, copie o comando à seguir e cole-o no terminal:

No nosso exemplo:

\curl -sSL https://get.rvm.io | bash

Se tudo der certo, vai aparecer uma tela assim:

Feche o Windows Terminal. Posteriormente a isso, abra-o novamente para tirar a prova real se a instalação do RVM deu certo ou não. Dê um:

rvm -v

Se a instalação tiver sido bem sucedida vai aparecer isso aqui:

Uma vez instalado o RVM podemos baixar a nossa primeira versão do Ruby. Vá ao site oficial da linguagem e veja qual é a current version do momento.
Pegue a numeração da current version e aplique o seguinte comando no terminal (contendo essa versão):
'rvm install '.

Exemplo prático, eu quero a versão 3.4.7:

 rvm install 3.4.7

O processo de instalação será exibido no terminal.

Dê um ‘rvm list’ para checar se a versão do Ruby que queremos foi instalada de fato.

8 - INSTALAÇÃO DO POSTGRESQL

No Windows Terminal, digite:

sudo apt install postgresql postgresql-contrib libpq-dev

Nota: Esse comando serve para instalar o PostgreSQL, os módulos adicionais (postgresql-contrib) e a biblioteca de desenvolvimento (libpq-dev).

Durante a instalação ele pede a senha do seu usuário do Ubuntu, bem como pergunta se você deseja seguir com o processo de instalação.

Vamos checar a versão do PostgreSQL que foi instalada.

Para isso utilizamos o seguinte comando no terminal.

psql --version

Apesar de instalado o PostgreSQL ainda não está funcionando, para que ele funcione precisamos startá-lo.
Mas antes disso precisamos setar uma nova senha para o SGBD.
Alterando a senha do usuário postgres no sistema (usuário padrão do PostgreSQL).

Dê o comando:

sudo passwd postgres

Insira a senha que deseja e depois repita-a e ele dará uma mensagem de sucesso.

Startando o PostgreSQL

Para isso vamos dar o comando para startar o serviço:

sudo service postgresql start

E depois vamos checar se o serviço/banco está ativo com um:

sudo service postgresql status

Entrando no PostgreSQL com o usuário postgres

Podemos acessar o console interativo do PostgreSQL (psql) como usuário postgres dando o seguinte comando:

sudo -u postgres psql

Esse comando vai abrir o terminal, para trabalharmos com o PostgreSQL.

O banco já está funcionando e a instalação do PostgreSQL já foi concluída!

9 - INSTALAÇÃO DO VSCODE

Se você já tiver o VSCode instalado na sua máquina, no seu Windows mesmo, não há a necessidade de baixar uma nova versão no WSL 2. Vamos utilizar o VSCode baixado no Windows mesmo.

Caso ainda não possua o editor de código:

Acesse o site oficial para baixar.
Veja esse tutorialrápido para instalação.

10 - CONFIGURANDO EXTENSÃO NO VSCODE

Abra o VSCode que foi instalado.
Uma vez neste clique neste botão para acessar as extensões:

Digite ‘WSL’ e instale a extensão indicada:

Há também outras 2 sugestões de extensões para quem trabalha com o VSCode e com o Ruby/Rails:

A Material Icon Theme - Para que o seu projeto, quando você abre no VSCode saia com aqueles ícones todos bonitinhos.
E essa aqui - Que muda as cores gerais do seu VScode.

11 - INSTALAÇÃO DO RAILS

Você pode instalar o Rails de maneira global no seu sistema. Mas não é uma prática recomendada. o ideal é instalar a versão do Rails especificamente na pasta de cada projeto.

Portanto, vamos começar criando uma pasta para os nossos projetos.

11.1 - Consultando o acesso as pastas em diferentes sistemas

Para evitar problemas de desempenho e de compatibilidade as pastas do nosso projeto NÃO serão criadas no Windows, ou seja, no caminho (/mnt/c/).

Vamos ao Windows Terminal para acessar a pasta do usuário no Ubuntu.

Para consultar essa pasta vamos dar o comando:

pwd

Nota: Esse comando vem de print working directory e serve para mostrar a sua pasta atual e o caminho para ela. Ou seja, o comando localiza aonde você está dentro da hierarquia de pastas.

Por exemplo, ao dar esse comando no Ubuntu vamos ter:

Já no Windows esse caminho estará bem aqui:

11.2 - Criando a pasta para os seus projetos no Ubuntu

Para criar a pasta, escolha e navegue até a pasta mãe - onde deseja deixar os seus projetos Rails - e dê o comando 'mkdir + nome_da_pasta_do_seu_projeto'.

Exemplo:

mkdir Projetos

11.3 - Mude para dentro da pasta que foi criada

Para isso utilize o comando:

cd Projetos

Ou 'cd nomedasuapasta'

11.4 - Instalando o Rails na pasta de Projetos

O Rails além de ser um framework é uma Gem, logo é instalado como uma. Os pacotes no Ruby são Gems.

Aqui você pode acompanhar todas as versões do Rails.

Se quiser instalar uma versão mais específica do Rails, dê este comando no terminal:

gem install rails -v 8.0.1

Se eu quiser instalar a versão mais recente e atualizada do Rails eu dou o comando:

gem install rails

A instalação do Rails vai gerar algo semelhante a isso:

11.5 - Checando se o Rails foi instalado com sucesso

rails -v

Dê um comando para consultar a versão do framework Rails.

12 - CRIANDO UM PROJETO NO RAILS NO VSCODE

Para criar um projeto no Rails dê o comando:

rails new nome_do_seu_projeto

Você também pode deixar algumas coisas pré-definidas, como por exemplo o SGBD que será utilizado:

rails new meu_projeto --database=postgresql

Ou deixar pré-definido se vai utilizar o Tailwind no projeto ou não:

rails new meu_projeto -d postgresql -c tailwind

Vamos gerar o nosso próprio projeto aqui:

rails new teste --database=postgresql

Aqui o projeto sendo criado:

Uma vez criado o projeto, se mude para dentro da pasta deste utilizando um 'cd teste'.

Posteriormente, abra o seu projeto com o Visual Studio Code e vá mexer nele. Edite-o como quiser. Para isso se utilize do comando: 'code .'

Repare que ele vai - na primeira vez que o VSCode abre ali - instalar o editor de código para o Linux x64:

Com isso, fico por aqui. Espero que tenham gostado da explicação sobre como instalar o setup para desenvolvimento em Ruby/Rails. Tentei deixar o mais detalhado possível, para evitar que as pessoas - mesmo as mais iniciantes em programação - consigam ter um bom entendimento desse processo de instalação da linguagem e dos demais componentes utilizados no desenvolvimento web com a linguagem.

Vejo vocês na próxima.

Tchau tchau.