Mergiraf – ferramenta orientada a AST para fusão de três vias no Git

O Mergiraf 0.4 projeto lançamento foi publicadoapresentando um driver para o Git implementar a fusão de três vias. Mergiraf oferece suporte à resolução de vários tipos de conflitos de mesclagem e pode ser usado com diferentes linguagens de programação e formatos de arquivo. Ele pode ser invocado de forma independente para lidar com conflitos que surgem com o Git padrão ou substituir o manipulador de mesclagem padrão do Git para aprimorar comandos como merge, revert, rebasee cherry-pick. O código é distribuído sob o Licença GPLv3. A nova versão adiciona suporte para Python, TOML, Scala e TypeScript, bem como otimizações de desempenho.

Problemas resolvidos por Mergiraf

O desenvolvimento de software program exemplifica um sistema incrivelmente complexo. Os sistemas complexos partilham uma característica: são inerentemente difíceis de gerir e o comportamento desejado não surge por acaso. Em vez disso, esses sistemas evoluem ao longo do tempo, passo a passo, com cada mudança cuidadosamente testada. Conseguir isso requer uma estrutura bem definida e ferramentas apropriadas.

A evolução de qualquer sistema complexo pode ser visualizada como uma árvore direcionada, onde a raiz representa um conjunto vazio de características, e cada nó – exceto a raiz – representa o resultado da aplicação de uma mutação ao seu pai.

No contexto de produtos de software program, cada nó é chamado de versãorepresentando um conjunto específico de recursos e anti-recursos. Qualquer alteração neste conjunto é considerada uma mutaçãoformando uma aresta no gráfico acíclico direcionado. Esses recursos são inerentemente abstratos; eles refletem não os sistemas físicos, mas a utilidade que os agentes inteligentes percebem nesses sistemas. Para transformar essas ideias em realidade, os desenvolvedores devem trabalhar com detalhes de baixo nível expressos em linguagens de programação.

Instantâneos e conjuntos de alterações

Para refinar gradualmente o código-fonte até um estado que exiba o comportamento desejado e documentar como isso é alcançado, os programadores usam instantâneos e conjuntos de alterações.

• UM instantâneo representa um estado específico do produto, capturando todos os detalhes de baixo nível.
• UM conjunto de alterações representa a transição entre instantâneos.

Normalmente, os instantâneos são derivados de conjuntos de alterações únicos, portanto, esses termos são frequentemente usados ​​de forma intercambiável. No entanto, há exceções, como mesclar confirmaçõesque resultam de múltiplas transições. Estes são notoriamente difíceis de gerir e geralmente são evitados.

Sistemas modernos de controle de versão, como o Git, fornecem recursos básicos para gerenciar fluxos de trabalho de desenvolvimento. Os desenvolvedores podem organizar instantâneos como gráficos acíclicos direcionados, anotá-los com comentários e reorganizar sua ordem conforme necessário. Essa funcionalidade ajuda os desenvolvedores a escrever históricos de projetos semanticamente significativos, que são essenciais para depurar e responder perguntas como:

• “Por que esse detalhe de baixo nível (por exemplo, uma variável) foi introduzido?”
• “Qual é a minha contribuição para este projeto?”
• “Quem implementou esse recurso e quando?”
• “Que mudança causou esse bug, embora não devesse?”

Ramificação e Colaboração

Os sistemas de controle de versão também suportam galhosque representam pedaços contínuos do histórico do projeto. Os desenvolvedores usam ramificações para:

• Implemente recursos específicos.
• Teste múltiplas implementações candidatas.
• Mix resultados de vários colaboradores sem mesclar tudo manualmente todas as vezes.

Um fluxo de trabalho típico envolve um filial principal representando o produto oficial, com ramificações laterais para cada funcionalidade. Os desenvolvedores sincronizam ramificações laterais com a ramificação principal regularmente (de preferência após cada commit) para:

• Trabalhe com a versão mais recente do produto.
• Detecte antecipadamente problemas causados ​​por outros desenvolvedores.

Desafios com a fusão

Combinar alterações de diferentes instantâneos (um processo que envolve encontrar um ancestral comum e aplicar alterações sequencialmente) pode levar a conflitos. As ferramentas VCS modernas contam com algoritmos de fusão linha por linhaque tratam os arquivos como sequências de linhas e aplicam algoritmos de estilo bioinformático para mesclá-los. Embora simples e common, esta abordagem tem limitações significativas:

1. Agnóstico de conteúdo: Algoritmos linha por linha ignoram a semântica do código-fonte.
2. Inconsistências: Freqüentemente, eles produzem mesclagens incorretas, exigindo que os desenvolvedores resolvam conflitos manualmente.
3. Suporte deficiente para grandes mudanças: Mudanças grandes ou triviais (por exemplo, reformatação de código) podem quebrar esses algoritmos.

Os desenvolvedores devem estudar cuidadosamente ambas as versões do código, resolver inconsistências e, às vezes, até reexaminar todo o projeto. Esses problemas são agravados quando o algoritmo não consegue detectar conflitos ou produz código que não funciona – por exemplo, quando um desenvolvedor renomeia uma variável enquanto outro a utiliza em um novo código.

Uma abordagem melhor

A solução superb envolve a utilização de um modelo semântico do código em vez de uma heurística linha por linha. Embora a pesquisa nesta área esteja em andamento há décadas, implementações práticas de código aberto só começaram a surgir no início de 2010, concentrando-se principalmente em Java.

• Árvore de goma: Uma ferramenta baseada em Java que gera representações abstratas de alterações no código-fonte, mas não oferece suporte à mesclagem de alterações prontas para uso.
• Difícil: Uma ferramenta baseada em Rust para visualizar diferenças no console, mas carece de funcionalidade para mesclar ou aplicar patches.

É aqui que entra Mergiraf.

O que Mergiraf traz para a mesa

Mergiraf é uma ferramenta baseada em Rust que aproveita o Cuidador de árvores analisador para análise gramatical livre de contexto. Ao contrário dos seus antecessores, Mergiraf concentra-se em resolvendo automaticamente conflitos de mesclagem em vez de apenas visualizar diferenças.

Principais recursos

1. Resolução automática de conflitos de mesclagem:
   • Usa o algoritmo do GumTree para geração de patches.
   • Adapta o algoritmo do Spork para aplicar alterações.
2. Suporte para vários idiomas:
   • Python, TOML, Scala, TypeScript e muito mais.
3. Compacto e eficiente:

4. Visualização de conflitos:
   • Ajuda os desenvolvedores a compreender e resolver problemas não resolvidos.

Limitações

• Serialização de patches:
  • Mergiraf ainda não suporta serialização de patches para aplicações posteriores, embora isso possa ser implementado através dos logs de eventos do GumTree.
• Consciência de estilo world:
  • Não tem suporte para estilos globais (por exemplo, .editorconfig), tornando-o menos eficaz para lidar com grandes alterações de formatação.

Exemplo

Dados os seguintes arquivos:

Arquivo base (base.py)

tab_indentation = True

foo = 1

def fundamental():
    print(foo + 2 + 3)

Arquivo A modificado (a.py)

from icecream import ic

foo = 1

def fundamental():
    ic(foo + 2 + 3)

class Baz:
    def __init__(self):
        """Baz class"""

Arquivo B modificado (b.py)

bar = 1

def fundamental():
    print(bar + 2 + 3)

Execução

./mergiraf merge ./base.py ./a.py ./b.py -x a.py -y b.py -s base.py -o ./res.py

Resultado

from icecream import ic

bar = 1

def fundamental():
    ic(bar + 2 + 3)

class Baz:
    def __init__(self):
        """Baz class"""

Esta saída resolve os conflitos de mesclagem, mantendo as alterações de ambas as ramificações e preservando a semântica do código. No entanto, a combinação de tabulações e espaços na indentação revela uma área a ser melhorada: Mergiraf deve integrar-se melhor com .editorconfig ou ferramentas semelhantes para impor estilos globais.

Conclusão

Mergiraf representa um avanço significativo na fusão de ferramentas para Git. Ao aproveitar árvores de sintaxe abstratas (ASTs), ele fornece aos desenvolvedores uma maneira mais confiável de resolver conflitos, suportando uma ampla variedade de linguagens e fluxos de trabalho. Embora existam áreas para melhoria, as inovações do Mergiraf o tornam uma escolha atraente para fluxos de trabalho modernos de desenvolvimento de software program.