Rails engine vs gems e como desenvolver e implementar

Introdução

No universo do Ruby on Rails, tanto as engines quanto as gems desempenham papéis fundamentais na extensão da funcionalidade das aplicações. Apesar de suas semelhanças superficiais, elas atendem a propósitos distintos e têm implicações diferentes no ciclo de desenvolvimento. Neste artigo, vamos desvendar as diferenças entre Rails engines e gems, discutir quando é apropriado usar cada uma e explorar os desafios associados. Além disso, apresentaremos um exemplo prático de como desenvolver uma Rails engine.

O Que São Gems?

Gems são pacotes de código Ruby que adicionam funcionalidades específicas a projetos Rails. Elas são ideais para compartilhar código reutilizável entre diferentes projetos, como ferramentas de autenticação ou integração com APIs.

Quando Usar Gems?

• Para funcionalidades que são comuns a muitos projetos.
• Quando a funcionalidade desejada é bem definida e isolada.

Problemas Comuns com Gems

• Gerenciamento de dependências pode se tornar complexo.
• Atualizações e manutenção podem ser desafiadoras se a gem não for ativamente mantida.

O Que São Rails Engines?

Rails engines são mini-aplicações que fornecem funcionalidades em um namespace isolado, permitindo uma abordagem modular ao desenvolvimento de aplicações Rails.

Quando Usar Rails Engines?

• Para modularizar grandes aplicações Rails.
• Quando você precisa de isolamento completo de uma parte da aplicação, incluindo rotas, modelos e visualizações.

Problemas Comuns com Rails Engines

• Maior complexidade no desenvolvimento e integração.
• Pode aumentar a complexidade do roteamento e da manutenção do aplicativo principal.

Desenvolvendo uma Rails Engine: Um Exemplo Simples

1. Criação da Engine:
   Execute o comando rails plugin new math_engine --mountable para gerar uma nova engine com sua própria estrutura de diretórios.
2. Desenvolvimento da Funcionalidade:
   Adicione modelos, controladores, visualizações e assets na engine como faria em um aplicativo Rails.
3. Montagem da Engine:
   No config/routes.rb do aplicativo principal, monte a engine com o código mount MathEngine::Engine, at: "/math_engine". Isso disponibiliza a engine em uma sub-rota do seu aplicativo.
4. Utilização da Engine:
   A engine agora pode ser utilizada como parte integrante do seu aplicativo principal.

Criando uma Rails Engine para Operações Matemáticas

Rails Engines são uma maneira poderosa de adicionar funcionalidades reutilizáveis aos seus aplicativos Rails. Neste tutorial, vamos criar uma engine simples que pode somar ou multiplicar dois números.

Passo 1: Criando a Engine

Primeiro, precisamos criar nossa engine. Abra o terminal e execute o seguinte comando:

rails plugin new math_engine --mountable

Isso criará uma nova engine chamada MathEngine com sua própria estrutura de diretório isolada.

Passo 2: Configurando a Engine

Navegue até o diretório da sua engine:

cd math_engine

Dentro da engine, você encontrará uma estrutura de diretórios semelhante a um aplicativo Rails. Vamos adicionar nossa lógica de negócios.

Passo 3: Adicionando Funcionalidades

Vamos criar um controlador para lidar com as operações matemáticas. No diretório da sua engine, execute:

rails g controller Calculations add multiply

Isso gerará um controlador com duas ações: add e multiply.

Passo 4: Escrevendo a Lógica de Negócios

Abra o arquivo app/controllers/math_engine/calculations_controller.rb e adicione a seguinte lógica:

module MathEngine
  class CalculationsController < ApplicationController
    def add
      @result = params[:a].to_i + params[:b].to_i
      render plain: "Resultado: #{@result}"
    end

    def multiply
      @result = params[:a].to_i * params[:b].to_i
      render plain: "Resultado: #{@result}"
    end
  end
end

Passo 5: Configurando Rotas

No arquivo config/routes.rb da sua engine, adicione:

MathEngine::Engine.routes.draw do
  get 'add/:a/:b', to: 'calculations#add'
  get 'multiply/:a/:b', to: 'calculations#multiply'
end

Isso mapeia as rotas para as ações do controlador.

Passo 6: Montando a Engine no Aplicativo Principal

No aplicativo Rails principal, adicione a seguinte linha ao arquivo config/routes.rb:

mount MathEngine::Engine, at: "/math"

Isso montará a engine no caminho /math do seu aplicativo.

Passo 7: Testando a Engine

Inicie o servidor Rails no aplicativo principal e visite:

• http://localhost:3000/math/add/1/2 para testar a adição.
• http://localhost:3000/math/multiply/3/4 para testar a multiplicação.

Você deverá ver os resultados das operações matemáticas.

Integração

Integrar uma Rails Engine em um projeto Rails é um processo relativamente simples. Aqui está um guia passo a passo sobre como fazer isso:

Passo 1: Adicione a Engine ao seu Gemfile

Se você criou a engine localmente e ela não está hospedada em um repositório de gems como o RubyGems, você pode apontar para o caminho local da engine no seu Gemfile. Supondo que sua engine se chame math_engine e esteja no mesmo diretório que seu aplicativo Rails, você adicionaria o seguinte:

gem 'math_engine', path: '../math_engine'

Se a engine estiver hospedada em um repositório git, você pode apontar para o repositório:

gem 'math_engine', git: 'https://github.com/seu-usuario/math_engine.git'

Depois de adicionar a engine ao seu Gemfile, execute:

bundle install

Passo 2: Monte a Engine no seu Aplicativo

Para montar a engine no seu aplicativo Rails, você precisa adicionar uma rota no arquivo config/routes.rb do seu aplicativo principal. Isso dirá ao seu aplicativo onde a engine pode ser acessada. Por exemplo:

# config/routes.rb
Rails.application.routes.draw do
  # outras rotas

  mount MathEngine::Engine, at: '/math'
end

Com isso, todas as rotas definidas na engine estarão disponíveis sob o caminho /math no seu aplicativo.

Passo 3: Verifique as Migrations

Se a sua engine contém migrations e você deseja que elas sejam executadas no banco de dados do aplicativo principal, você deve copiá-las para o aplicativo principal. Isso pode ser feito com o seguinte comando:

rake math_engine:install:migrations

Passo 4: Pré-compilar os Assets

Se a sua engine contém assets como JavaScripts, CSS ou imagens, você deve pré-compilá-los no aplicativo principal. Isso pode ser feito adicionando a seguinte linha ao config/initializers/assets.rb do seu aplicativo principal:

Rails.application.config.assets.precompile += %w( math_engine/application.js math_engine/application.css )

Substitua math_engine/application.js e math_engine/application.css pelos caminhos corretos dos seus assets se eles forem diferentes.

Passo 5: Teste a Engine

Depois de montar a engine e resolver as migrations e assets, inicie o servidor Rails e navegue até o caminho onde a engine foi montada (por exemplo, http://localhost:3000/math). Você deve ser capaz de acessar as funcionalidades fornecidas pela engine.

Passo 6: Personalize Conforme Necessário

Você pode precisar fazer ajustes adicionais dependendo das especificidades da sua engine e do aplicativo principal. Isso pode incluir configurar inicializadores, ajustar as configurações de autenticação ou autorização, ou modificar a forma como os assets são gerenciados.

Conclusão

Integrar uma Rails Engine em seu projeto Rails é uma ótima maneira de modularizar funcionalidades e promover a reutilização de código. Com esses passos, você deve ser capaz de integrar e usar sua engine dentro do seu aplicativo Rails principal.

Referências

• Rails Guides: Engines
• API Dock: Rails::Engine