Como instalar o Ruby on Rails com rbenv no macOS

Introdução

Ruby on Rails é uma pilha de aplicativos popular para desenvolvedores que desejam criar sites e aplicativos da web. A linguagem de programação Ruby, combinada com o framework de desenvolvimento Rails, torna o desenvolvimento de aplicativos rápido e eficiente.

Uma maneira de instalar o Ruby e o Rails é usando a ferramenta de linha de comando rbenv. O uso do rbenv fornecerá um ambiente bem controlado e robusto para o desenvolvimento de suas aplicações Ruby on Rails, permitindo que você alterne facilmente sua versão de trabalho do Ruby conforme necessário.

O rbenv oferece suporte para especificar versões de Ruby específicas para aplicativos, permite que você altere o Ruby global para cada usuário e permite que você use uma variável de ambiente para substituir a versão do Ruby.

Neste tutorial, você usará o rbenv para instalar e configurar o Ruby on Rails em sua máquina local macOS.

Pré-requisitos

Para seguir este tutorial, você precisará:

• Um computador ou máquina virtual com o macOS instalado, com acesso administrativo a essa máquina e uma conexão com a internet. Este tutorial foi testado no macOS 12.4 Monterey.
• Node.js instalado na sua máquina macOS, conforme explicado em Como Instalar o Node.js e Criar um Ambiente de Desenvolvimento Local no macOS. Algumas características do Rails, como o Asset Pipeline, dependem de um Tempo de Execução JavaScript. O Node.js fornece essa funcionalidade.
• O gerenciador de pacotes Homebrew instalado na sua máquina macOS.

Passo 1 — Instalando o rbenv

Neste passo, você irá instalar o rbenv e garantir que ele inicie automaticamente durante a inicialização. Para fazer isso no macOS, este tutorial usará o gerenciador de pacotes Homebrew.

Para baixar o pacote rbenv com o Homebrew, execute o seguinte comando:

brew install rbenv

Isso instalará o rbenv e o [ruby-build] (https://github.com/rbenv/ruby-build) plugin. Este plugin adiciona o comando rbenv install, que simplifica o processo de instalação de novas versões do Ruby. Isso pode instalar várias outras dependências e levar algum tempo.

Em seguida, você adicionará o comando eval "$(rbenv init -)" ao seu arquivo ~/.bash_profile para fazer com que o rbenv seja carregado automaticamente quando você abrir o Terminal. Para fazer isso, abra o seu arquivo .bash_profile no nano ou no seu editor de texto favorito:

nano .bash_profile

Adicione a seguinte linha ao arquivo:

eval "$(rbenv init -)"

Salve e saia do arquivo.

Em seguida, aplique as alterações feitas ao seu arquivo ~/.bash_profile à sua sessão de terminal atual:

source ~/.bash_profile

Para verificar se o rbenv está configurado corretamente, use o comando type, que exibirá mais informações sobre o comando rbenv:

type rbenv

Sua janela do terminal exibirá o seguinte:

Output
rbenv is a function
rbenv ()
{
    local command;
    command="${1:-}";
    if [ "$#" -gt 0 ]; then
        shift;
    fi;
    case "$command" in
        rehash | shell)
            eval "$(rbenv "sh-$command" "$@")"
        ;;
        *)
            command rbenv "$command" "$@"
        ;;
    esac
}

Neste ponto, você tem tanto o rbenv quanto o ruby-build instalados em sua máquina. Isso permitirá que você instale o Ruby a partir da linha de comando no próximo passo.

Passo 2 — Instalando o Ruby

Com o plugin ruby-build agora instalado, você pode instalar qualquer versão do Ruby que precisar através de um único comando. Neste passo, você escolherá uma versão do Ruby, a instalará em sua máquina e então verificará a instalação.

Primeiro, use a flag -l para listar as versões disponíveis do Ruby. Note que versões recentes menores não listadas também podem estar disponíveis. Por exemplo, se a saída deste comando listar o Ruby 3.0.5, você provavelmente também poderá instalar o 3.0.4.

rbenv install -l

Output
2.6.10
2.7.6
3.0.4
3.1.2
jruby-9.3.6.0
mruby-3.1.0
picoruby-3.0.0
rbx-5.0
truffleruby-22.1.0
truffleruby+graalvm-22.1.0

A saída desse comando será uma longa lista de versões entre as quais você pode escolher para instalar.

Para este tutorial, vamos instalar o Ruby 3.1.2:

rbenv install 3.1.2

A instalação do Ruby pode ser um processo demorado, então esteja preparado para que a instalação leve algum tempo para ser concluída.

Assim que a instalação estiver feita, defina-a como sua versão padrão do Ruby com o subcomando global:

rbenv global 3.1.2

Verifique se o Ruby foi instalado corretamente verificando o número da versão:

ruby -v

Sua saída será algo parecido com isto:

Output
ruby 3.1.2p20 (2022-04-12 revision 4491bb740a) [x86_64-darwin21]

Para instalar e usar uma versão diferente do Ruby, execute os comandos rbenv com um número de versão diferente, como rbenv install 2.7.6 e rbenv global 2.7.6.

Agora você tem uma versão do Ruby instalada e definiu sua versão padrão do Ruby. Em seguida, você se preparará para trabalhar com pacotes e bibliotecas Ruby, ou gems, o que permitirá então que você instale o Rails.

Passo 3 — Trabalhando com Gems

Gems são pacotes de bibliotecas e programas Ruby que podem ser distribuídos em todo o ecossistema Ruby. Você usa o comando gem para gerenciar essas gems. Neste passo, você configurará o comando gem para se preparar para a instalação do Rails.

Quando você instala um gem, o processo de instalação gera documentação local. Isso pode adicionar uma quantidade significativa de tempo a cada processo de instalação do gem, então você pode desativar a geração de documentação local criando um arquivo chamado ~/.gemrc que contenha uma configuração para desativar esse recurso:

echo "gem: --no-document" > ~/.gemrc

Feito isso, use o comando gem para instalar o Bundler, uma ferramenta que gerencia as dependências de gem para projetos. Isso é necessário para que o Rails funcione corretamente:

gem install bundler

Você verá uma saída como esta:

Output
Fetching: bundler-2.3.18.gem
Successfully installed bundler-2.3.18
1 gem installed

Você pode usar o comando gem env para aprender mais sobre o ambiente e configuração de gems. Para ver a localização dos gems instalados, use o argumento home, como este:

gem env home

Você verá uma saída semelhante a esta:

/Users/sammy/.rbenv/versions/3.1.2/lib/ruby/gems/3.1.0

Agora que você configurou e explorou seu fluxo de trabalho com gems, está livre para instalar o Rails.

Passo 4 — Instalando o Rails

Para instalar o Rails, use o comando gem install:

gem install rails

O comando gem instala o gem que você especificar, bem como todas as dependências. O Rails é um framework complexo para desenvolvimento web e possui muitas dependências, então o processo levará algum tempo para ser concluído. Eventualmente, você verá uma mensagem informando que o Rails está instalado, juntamente com suas dependências:

Output
...
Successfully installed rails-7.0.3.1
35 gems installed

gem search '^rails$' --all
gem install rails -v 4.2.7

rbenv funciona criando um diretório de shims, ou bibliotecas que interceptam chamadas e as alteram ou redirecionam. Neste caso, os shims apontam comandos Ruby para os arquivos usados pela versão Ruby que está atualmente habilitada. Através do subcomando rehash, o rbenv mantém os shims nesse diretório para corresponder a cada comando Ruby em todas as versões instaladas do Ruby em seu servidor. Sempre que você instala uma nova versão do Ruby ou uma gem que fornece comandos, como o Rails, você deve usar rehash.

Para recriar o diretório de shims, execute o seguinte comando:

rbenv rehash

Verifique a instalação do Rails imprimindo sua versão com este comando:

rails -v

Você verá a versão do Rails que foi instalada:

Output
Rails 7.0.3.1

Com o Rails instalado com sucesso, você pode começar a testar sua instalação do Ruby on Rails e começar a desenvolver aplicações web. No próximo passo, você aprenderá como atualizar e desinstalar o rbenv e o Ruby.

Passo 5 — Atualizando e Desinstalando o rbenv e o Ruby

Ao manter projetos, é útil saber como atualizar e desinstalar quando necessário. Nesta etapa, você irá atualizar o rbenv e, em seguida, desinstalar o Ruby e o rbenv de sua máquina.

Você pode atualizar o rbenv e o ruby-build usando o Homebrew executando o seguinte comando:

brew upgrade rbenv ruby-build

Se o rbenv ou o ruby-build precisarem ser atualizados, o Homebrew fará isso automaticamente para você. Se sua configuração já estiver atualizada, você verá uma saída semelhante à seguinte:

Output
Warning: rbenv 1.2.0 already installed
Warning: ruby-build 20220713 already installed

Isso garantirá que estejamos usando a versão mais recente do rbenv disponível.

Ao baixar versões adicionais do Ruby, você pode acumular mais versões do que gostaria em seu diretório ~/.rbenv/versions. Usando o subcomando uninstall do plugin ruby-build, você pode remover essas versões anteriores.

Por exemplo, execute o seguinte para desinstalar a versão do Ruby 2.1.3:

rbenv uninstall 2.1.3

Com o comando rbenv uninstall, você pode limpar versões antigas do Ruby para que você não tenha mais instaladas do que está usando atualmente.

Se você decidiu que não deseja mais usar o rbenv, pode removê-lo do seu sistema.

Para fazer isso, primeiro abra o arquivo ~/.bash_profile em seu editor:

nano ~/.bash_profile

Encontre e remova a seguinte linha do arquivo para impedir que o rbenv seja iniciado quando você abrir o Terminal:

...
eval "$(rbenv init -)"

Depois de excluir esta linha, salve o arquivo e saia do editor.

Execute o seguinte comando para aplicar as alterações ao seu shell:

source ~/.bash_profile

Em seguida, remova o rbenv e todas as versões instaladas do Ruby com este comando:

rm -rf `rbenv root`

Finalmente, remova o pacote rbenv em si com o Homebrew:

brew uninstall rbenv

Verifique a versão do rbenv para garantir que tenha sido desinstalada:

rbenv -v

Você obterá a seguinte saída:

Output
-bash: /usr/local/bin/rbenv: No such file or directory

Isso significa que você removeu com sucesso o rbenv do seu sistema.

Conclusão

Neste tutorial, você instalou o Ruby on Rails com o rbenv no macOS. A partir daqui, você pode aprender mais sobre codificação em Ruby com nossa série Como Programar em Ruby. Você também pode explorar como usar o Ruby on Rails com o PostgreSQL em vez do seu banco de dados sqlite3 padrão, o que proporciona mais escalabilidade, centralização e estabilidade para suas aplicações.