Usando estratégias de mesclagem para gerar pacotes e especificar arquivos

Você pode usar estratégias de mesclagem para gerar pacotes com ressíntese e especificar arquivos para atualizações de gerenciamento do ciclo de vida de esquemas personalizados. Ao aproveitar as estratégias de resythensis e mesclagem, você pode gerenciar atualizações e controlar quais arquivos são atualizados durante as implantações. Você também pode escrever suas próprias estratégias para controlar como as mudanças são mescladas em CodeCatalyst projetos existentes.

Gerando arquivos com ressíntese

A ressíntese pode mesclar o código-fonte produzido por um blueprint com o código-fonte que foi gerado anteriormente pelo mesmo blueprint, permitindo que as alterações em um blueprint sejam propagadas para projetos existentes. As mesclagens são executadas a partir da resynth() função nos pacotes de saída do blueprint. A ressíntese primeiro gera três pacotes representando diferentes aspectos do plano e do estado do projeto. Ele pode ser executado manualmente localmente com o yarn blueprint:resynth comando, que criará os pacotes se eles ainda não existirem. Trabalhar manualmente com os pacotes permitirá que você simule e teste o comportamento da ressíntese localmente. Por padrão, os blueprints só executam a ressíntese nos repositórios abaixo, src/* já que somente essa parte do pacote normalmente está sob controle de origem. Para obter mais informações, consulte Ressíntese.

• existing-bundle- Esse pacote é uma representação do estado existente do projeto. Isso é construído artificialmente pela computação de síntese para fornecer ao plano um contexto sobre o que está no projeto em que está sendo implantado (se houver). Se algo já existir nesse local ao executar a ressíntese localmente, ele será redefinido e respeitado como uma simulação. Caso contrário, ele será definido para o conteúdo doancestor-bundle.

• ancestor-bundle- Esse é o pacote que representa a saída do blueprint se tiver sido sintetizado com algumas opções e/ou versões anteriores. Se for a primeira vez que esse blueprint está sendo adicionado a um projeto, então o ancestral não existe, então ele está definido com o mesmo conteúdo do. existing-bundle Localmente, se esse pacote já existir nesse local, ele será respeitado como uma simulação.

• proposed-bundle- Este é o pacote que simula o blueprint se ele foi sintetizado com algumas novas opções e/ou versões. Esse é o mesmo pacote que seria produzido pela synth() função. Localmente, esse pacote é sempre substituído.

Cada pacote é criado durante uma fase de ressíntese que pode ser acessada a partir da classe de blueprint abaixo. this.context.resynthesisPhase

• resolved-bundle- Esse é o pacote final, que é uma representação do que é empacotado e implantado em um projeto. CodeCatalyst Você pode ver quais arquivos e diffs são enviados para os mecanismos de implantação. Essa é a saída da resynth() função que resolve mesclagens entre os outros três pacotes.

A mesclagem de três vias é aplicada tomando a diferença entre o ancestor-bundle proposed-bundle e e adicionando-a ao existing-bundle para gerar o. resolved-bundle Todas as estratégias de mesclagem resolvem arquivos para o. resolved-bundle A ressíntese resolve o alcance desses pacotes com as estratégias de mesclagem do blueprint resynth() e produz o pacote resolvido a partir do resultado.

Usando estratégias de mesclagem

Você pode usar uma estratégia de mesclagem oferecida pela biblioteca de blueprints. Essas estratégias fornecem maneiras de resolver saídas de arquivos e conflitos para arquivos mencionados na Gerando arquivos com ressíntese seção.

• alwaysUpdate- Uma estratégia que sempre se resolve com o arquivo proposto.

• neverUpdate- Uma estratégia que sempre se resolve com o arquivo existente.

• onlyAdd- Uma estratégia que resolve o arquivo proposto quando um arquivo existente ainda não existe. Caso contrário, resolve para o arquivo existente.

• threeWayMerge- Uma estratégia que executa uma fusão tripla entre os arquivos ancestrais existentes, propostos e comuns. O arquivo resolvido pode conter marcadores de conflito se os arquivos não puderem ser mesclados de forma limpa. O conteúdo dos arquivos fornecidos deve ser codificado em UTF -8 para que a estratégia produza uma saída significativa. A estratégia tenta detectar se os arquivos de entrada são binários. Se a estratégia detectar um conflito de mesclagem em um arquivo binário, ela sempre retornará o arquivo proposto.

• preferProposed- Uma estratégia que executa uma fusão tripla entre os arquivos ancestrais existentes, propostos e comuns. Essa estratégia resolve conflitos selecionando o lado do arquivo proposto de cada conflito.

• preferExisting- Uma estratégia que executa uma fusão tripla entre os arquivos ancestrais existentes, propostos e comuns. Essa estratégia resolve conflitos selecionando o lado do arquivo existente de cada conflito.

Para ver o código-fonte das estratégias de mesclagem, consulte o repositório de código aberto GitHub .

Especificação de arquivos para atualizações de gerenciamento do ciclo de vida

Durante a ressíntese, os blueprints controlam como as alterações são mescladas em um repositório de origem existente. No entanto, talvez você não queira enviar atualizações para todos os arquivos do seu blueprint. Por exemplo, códigos de exemplo, como CSS folhas de estilo, devem ser específicos do projeto. A estratégia de mesclagem de três vias é a opção padrão se você não especificar outra estratégia. Os blueprints podem especificar quais arquivos eles possuem e quais não possuem, especificando estratégias de mesclagem na própria construção do repositório. Os blueprints podem atualizar suas estratégias de mesclagem, e as estratégias mais recentes podem ser usadas durante a ressíntese.

const sourceRepo = new SourceRepository(this, {
      title: 'my-repo',
    });
    sourceRepo.setResynthStrategies([
      {
        identifier: 'dont-override-sample-code',
        description: 'This strategy is applied accross all sample code. The blueprint will create sample code, but skip attempting to update it.',
        strategy: MergeStrategies.neverUpdate,
        globs: [
          '**/src/**',
          '**/css/**',
        ],
      },
    ]);

Várias estratégias de mesclagem podem ser especificadas, e a última estratégia tem precedência. Os arquivos descobertos são padronizados para um three-way-merge similar ao Git. Existem várias estratégias de mesclagem fornecidas por meio da MergeStrategies construção, mas você pode escrever a sua própria. As estratégias fornecidas seguem o driver de estratégia do git merge.

Escrevendo estratégias de mesclagem

Além de usar uma das estratégias de fusão de compilações fornecidas, você também pode escrever suas próprias estratégias. As estratégias devem seguir uma interface estratégica padrão. Você deve escrever uma função de estratégia que pegue versões de um arquivo doexisting-bundle,proposed-bundle, eancestor-bundle, e as mescle em um único arquivo resolvido. Por exemplo:

type StrategyFunction = (
   /**
   * file from the ancestor bundle (if it exists)
   */
    commonAncestorFile: ContextFile | undefined, 
   /**
   * file from the existing bundle (if it exists)
   */
    existingFile: ContextFile | undefined,
   /**
   * file from the proposed bundle (if it exists)
   */ 
    proposedFile: ContextFile | undefined, 
    options?: {}) 
    /**
    * Return: file you'd like in the resolved bundle
    * passing undefined will delete the file from the resolved bundle
    */ 
=> ContextFile | undefined;

Se os arquivos não existirem (forem indefinidos), esse caminho de arquivo não existirá nesse pacote de localização específico.

Exemplo:

strategies: [
          {
            identifier: 'dont-override-sample-code',
            description: 'This strategy is applied across all sample code. The blueprint will create sample code, but skip attempting to update it.',
            strategy: (ancestor, existing, proposed) => {
                const resolvedfile = ...
                ...
                // do something
                ...
                return resolvedfile
            },
            globs: [
              '**/src/**',
              '**/css/**',
            ],
          },
        ],