Como Usar o GitHub Copilot com Scopes do Active Record no Ruby on Rails

Desenvolvedores Ruby on Rails frequentemente escrevem scopes do Active Record para encapsular consultas comuns ao banco de dados. Escrever esses scopes manualmente pode ser repetitivo e propenso a erros, especialmente ao lidar com joins complexos ou lógica condicional. O GitHub Copilot pode gerar definições de scope, casos de teste e até sugestões de migração diretamente no seu editor. Este artigo explica como configurar o Copilot para um projeto Rails e usá-lo para criar, refinar e depurar scopes do Active Record de forma eficiente.

Você aprenderá os prompts e padrões exatos que acionam a geração precisa de scopes. As instruções cobrem comandos do Copilot Chat, conclusões inline e como lidar com casos extremos como scodes encadeados ou lambdas parametrizados. Ao final, você conseguirá reduzir o tempo gasto com código de consulta repetitivo, mantendo as convenções do Rails.

Como o Copilot Interpreta a Sintaxe de Scopes do Active Record

O GitHub Copilot aprende com o contexto do arquivo atual e do projeto. Quando você digita scope : dentro de uma classe de modelo, o Copilot analisa definições de modelos próximas, scopes existentes e o esquema do banco de dados, se um arquivo de esquema estiver presente. Ele então sugere o bloco completo do scope, incluindo o operador lambda -> e a condição da consulta. O Copilot também reconhece padrões comuns do Rails como where, joins, includes e cláusulas order.

O Copilot não lê seu banco de dados real. Ele depende do arquivo schema.rb ou structure.sql do seu projeto para inferir nomes de colunas e associações. Se esses arquivos estiverem ausentes ou desatualizados, as sugestões podem referenciar colunas incorretas. Mantenha seu arquivo de esquema atualizado executando rails db:migrate antes de usar o Copilot para gerar scopes.

Configurando o Copilot para um Projeto Ruby on Rails

Antes de gerar scopes, confirme que o Copilot está configurado corretamente para seu workspace Rails. Siga estas etapas:

1. Instale a extensão do Copilot
   Abra seu editor VS Code ou JetBrains. Vá até o painel de Extensões e procure por GitHub Copilot. Instale a extensão oficial e faça login com sua conta GitHub que possui uma assinatura ativa do Copilot.
2. Habilite o Copilot para o workspace
   No VS Code, abra a Paleta de Comandos com Ctrl+Shift+P. Digite Copilot: Sign In e siga o fluxo de autenticação. Para JetBrains, vá em Settings > Tools > GitHub Copilot e habilite o plugin.
3. Abra seu arquivo de modelo Rails
   Navegue até app/models/ e abra o modelo onde deseja adicionar um scope. Certifique-se de que o arquivo inclui class YourModel < ApplicationRecord e que o arquivo schema.rb está no diretório db/.
4. Verifique o acesso ao esquema
   Abra db/schema.rb e confirme que ele contém a definição da tabela para seu modelo. O Copilot usa esse arquivo para sugerir nomes de colunas nas condições do scope. Se o arquivo estiver vazio, execute rails db:schema:dump para regenerá-lo.

Gerando um Scope Básico com Conclusão Inline

As conclusões inline aparecem como texto cinza enquanto você digita. Para gerar um scope, comece digitando a palavra-chave scope dentro da sua classe de modelo. Por exemplo, abra app/models/post.rb e digite parcialmente scope :published, -> { where(published: true) }. O Copilot sugerirá o restante da linha. Aceite a sugestão pressionando Tab.

Se o Copilot não sugerir nada, digite a assinatura completa do método scope : e aguarde um segundo. A sugestão deve aparecer. Se não aparecer, verifique se o arquivo está salvo e se o arquivo de esquema está presente. Para um scope parametrizado, digite scope :recent, ->(days) { where('created_at > ?', days.days.ago) } e deixe o Copilot completar o corpo do lambda.

Usando o Copilot Chat para Scopes Complexos

O Copilot Chat permite descrever um scope em linguagem natural. Abra o painel de chat com Ctrl+Shift+I no VS Code ou clique no ícone do Copilot no JetBrains. Digite um prompt como: Crie um scope chamado 'with_comments' que retorne posts que tenham pelo menos um comentário. Use um left join. O Copilot Chat gerará o bloco de código:

scope :with_comments, -> { left_joins(:comments).where.not(comments: { id: nil }).distinct }

Você pode copiar o código diretamente para seu modelo. Para scopes encadeados, peça ao Copilot Chat para combinar dois scopes existentes. Por exemplo: Combine os scopes 'published' e 'recent' em um único scope chamado 'published_recent'. Ele produzirá o lambda mesclado.

Gerando Testes para Scopes

Após criar um scope, gere testes para verificar seu comportamento. Abra seu arquivo de teste para o modelo. No RSpec, esse arquivo é spec/models/post_spec.rb. Posicione o cursor dentro de um bloco describe e digite um comentário como # scope :published. O Copilot sugerirá um bloco de teste:

describe '.published' do
  let!(:published_post) { create(:post, published: true) }
  let!(:unpublished_post) { create(:post, published: false) }

  it 'returns only published posts' do
    expect(Post.published).to contain_exactly(published_post)
  end
end

Aceite a sugestão e ajuste os nomes das fábricas se necessário. Para usuários do Minitest, o Copilot gera blocos test com código de configuração semelhante.

Problemas Comuns ao Usar o Copilot para Scopes

O Copilot sugere um scope sem a seta lambda

Scopes do Rails exigem um lambda -> ou um objeto chamável. Se o Copilot omitir a seta, o scope lançará um ArgumentError. Adicione manualmente -> antes do bloco. Para evitar isso, sempre digite scope :name, -> { e deixe o Copilot preencher apenas a condição da consulta.

O Copilot usa um nome de coluna que não existe

Isso acontece quando o arquivo de esquema está desatualizado. Execute rails db:migrate:status para verificar migrações pendentes. Em seguida, execute rails db:migrate e rails db:schema:dump para atualizar o esquema. Feche e reabra o arquivo do modelo para forçar o Copilot a recarregar o contexto.

O Copilot gera um scope que usa SQL bruto quando existe um método AREL

O Copilot às vezes sugere strings SQL brutas como where("price > 100") em vez de usar where('price > ?', 100) ou um nó AREL. Substitua SQL bruto por consultas parametrizadas para prevenir injeção de SQL. Use o Copilot Chat com o prompt: Reescreva este scope para usar consultas parametrizadas.

Item	Conclusão Inline	Copilot Chat
Melhor para	Scopes simples de uma linha	Scopes complexos com várias linhas, joins ou condições
Método de entrada	Digitar código parcial	Descrever em linguagem natural
Geração de testes	Não disponível	Disponível via comando /tests
Refatoração de scopes existentes	Limitada	Sim, peça para combinar ou modificar
Dependência do arquivo de esquema	Alta	Alta

Se o Copilot Gerar Código de Scope Incorreto

O Copilot sugere um scope que não retorna um ActiveRecord::Relation

Um scope deve retornar um objeto relation. Se o Copilot inserir nil ou um array, o scope quebrará o encadeamento de métodos. Use o Copilot Chat com o prompt: Corrija este scope para retornar um ActiveRecord::Relation. Ele removerá retornos não-relation e adicionará all se necessário.

O Copilot cria um scope com um nome que conflita com um método existente

O Rails reserva nomes de métodos como new, create e destroy. Se o Copilot sugerir um scope chamado new, rejeite a sugestão e renomeie para recently_created ou outro nome sem conflito. Consulte a documentação da API do Rails para nomes de métodos reservados.

Agora você pode gerar, testar e refinar scopes do Active Record usando as conclusões inline do GitHub Copilot e o Copilot Chat. Mantenha seu arquivo de esquema atualizado e sempre verifique se os scopes gerados retornam um objeto relation. Para consultas complexas envolvendo múltiplos joins ou lógica condicional, use o Copilot Chat com prompts explícitos em vez de depender de sugestões inline. Como próximo passo, tente usar o Copilot para gerar código de migração para adicionar índices de banco de dados que suportem seus novos scopes.