As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

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.

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

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.

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/**',
            ],
          },
        ],