1. Por Que Refatorar e Modularizar?

Refatorar e modularizar um sistema Delphi não é apenas uma boa prática: é fundamental para garantir manutenção facilitada, reaproveitamento de código e escalabilidade do projeto ao longo do tempo. Projetos que crescem sem atenção a esses pilares sofrem com bugs recorrentes, dificuldade de implementar novas funcionalidades e obstáculos no onboarding de novos desenvolvedores.

Sinais de alerta clássicos:

• Presença de “God Form” ou “Objeto Deus”: Formulários com dezenas de métodos e variáveis, misturando UI, lógica de negócios e acesso a dados.

• Código espaguete: Dependências cruzadas entre units sem clareza de responsabilidades.

• Repetição excessiva: Trechos de código duplicados em várias partes do projeto.

• Dificuldade de testes: Alterar uma linha de código pode quebrar funcionalidades inesperadas.

Exemplo problema comum (God Form)

// Form principal que faz tudo
procedure TFormMain.ProcessarPagamento;
begin
  // Valida dados
  if EdtValor.Text = '' then
    ShowMessage('Informe um valor.');

  // Processa pagamento
  DMFinanceiro.RealizarPagamento(StrToFloat(EdtValor.Text));

  // Atualiza UI
  LblStatus.Caption := 'Pagamento realizado!';
end;

Problema: O formulário mistura validação, acesso a dados e manipulação de interface. Perde-se o princípio de responsabilidade única.

2. Diagnóstico Inicial

Antes de iniciar a refatoração, é importante diagnosticar os principais problemas. O uso de ferramentas específicas e atenção a “smells” indicam áreas crônicas que merecem intervenção.

Passos sugeridos:

• Analise o número de métodos em cada form/unit — formulários que concentram muitos métodos são candidatos à refatoração.

• Verifique dependências cruzadas através de uses em units. Dependências excessivas dificultam evolução do projeto.

• Utilize analisadores como Pascal Analyzer, FixInsight ou próprio Code Coverage do Delphi para identificar código morto, duplicado ou nunca executado.

Exemplo problema comum (Dependência cruzada):

// UnitA.pas
uses UnitB;

procedure TClassA.FazerAlgo;
begin
  TClassB.Execute; // Chama diretamente método da unit B
end;

// UnitB.pas
uses UnitA;

procedure TClassB.Execute;
begin
  TClassA.FazerAlgo; // Chama novamente método da unit A (referência circular)
end;

Problema: Dependência circular, tornando manutenção e testes muito complexos. Ideal é separar responsabilidades em units independentes e usar interfaces para comunicação.

Como identificar código morto:

procedure TFormMain.BotaoOcultoClick(Sender: TObject);
begin
  // Nunca chamado por estar desconectado de qualquer ação
end;

Ferramenta: Use Code Coverage ou análise por ferramenta externa para levantar métodos nunca chamados ou conectados a eventos.

Dicas rápidas para diagnóstico:

• Avalie componentes e eventos não utilizados no Object Inspector.

• Gere relatórios de cobertura para descobrir código que pode ser removido (Boat Anchor).

• Procure por repetições e padrões de “gagueira” (Stutter), como validações duplicadas ou chamadas redundantes.

procedure TFormMain.ProcessarPagamento;
begin
  // Valida dados
  if EdtValor.Text = '' then
    ShowMessage('Informe um valor.');

  // Processa pagamento
  DMFinanceiro.RealizarPagamento(StrToFloat(EdtValor.Text));

  // Atualiza UI
  LblStatus.Caption := 'Pagamento realizado!';
end;

// Classe para lógica de negócio
type
  TPagamentoService = class
  public
    function ValidarValor(const Valor: string): Boolean;
    procedure RealizarPagamento(const Valor: Double);
  end;

// Form (Apenas orquestra a interação)
procedure TFormMain.ProcessarPagamento;
var
  PagamentoService: TPagamentoService;
begin
  PagamentoService := TPagamentoService.Create;
  try
    if not PagamentoService.ValidarValor(EdtValor.Text) then
      ShowMessage('Informe um valor.')
    else
    begin
      PagamentoService.RealizarPagamento(StrToFloat(EdtValor.Text));
      LblStatus.Caption := 'Pagamento realizado!';
    end;
  finally
    PagamentoService.Free;
  end;
end;

procedure TFormMain.BotaoOcultoClick(Sender: TObject);
begin
  // Nunca chamado
end;

type
  IPagamentoService = interface
    ['{D8C4E353-9E19-4C47-BE85-D3F044D1D37A}']
    procedure RealizarPagamento(const Valor: Double);
  end;

// Implementação concreta
type
  TPagamentoService = class(TInterfacedObject, IPagamentoService)
  public
    procedure RealizarPagamento(const Valor: Double);
  end;

// Form usa apenas a interface
procedure TFormMain.ProcessarPagamento;
var
  PagamentoService: IPagamentoService;
begin
  PagamentoService := TPagamentoService.Create;
  PagamentoService.RealizarPagamento(StrToFloat(EdtValor.Text));
end;

// DataModule para dados financeiros
type
  TDMFinanceiro = class(TDataModule)
    qryPagamentos: TFDQuery;
    // Métodos para acesso e manipulação de dados
    procedure RealizarPagamento(const Valor: Double);
  end;

procedure TFormMain.ProcessarPagamento;
begin
  DMFinanceiro.RealizarPagamento(StrToFloat(EdtValor.Text));
end;