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á.

Uso de 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 ressíntese 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 alterações são mescladas aos projetos existentes do CodeCatalyst.

Gerar arquivos com ressíntese

A ressíntese pode mesclar o código-fonte produzido por um esquema com o código-fonte que foi gerado anteriormente pelo mesmo esquema, permitindo que as alterações em um esquema sejam propagadas para projetos existentes. As mesclagens são executadas a partir da função resynth() nos pacotes de saída do esquema. A ressíntese primeiro gera três pacotes que representam diferentes aspectos do esquema e do estado do projeto. Ela pode ser executada manualmente no local com o comando yarn blueprint:resynth, 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 esquemas só executam a ressíntese nos repositórios em src/*, já que somente essa parte do pacote normalmente está sob controle de origem. Para ter mais informações, consulte Ressíntese.

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

A mesclagem de três vias é aplicada tomando a diferença entre o ancestor-bundle e proposed-bundle 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 esquema durante resynth() e produz o pacote resolvido no resultado.

Usar estratégias de mesclagem

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

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

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

Durante a ressíntese, os esquemas controlam como as alterações são mescladas em um repositório de origem existente. No entanto, você talvez não queira enviar atualizações para todos os arquivos do seu esquema. Por exemplo, códigos de exemplo, como folhas de estilo CSS, 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 esquemas podem especificar quais arquivos possuem e quais não possuem, especificando estratégias de mesclagem no próprio constructo do repositório. Os esquemas podem atualizar as 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 usam como padrão uma mesclagem de três vias semelhante ao Git. Existem várias estratégias de mesclagem fornecidas por meio do constructo MergeStrategies, mas você pode escrever a sua própria. As estratégias fornecidas seguem o driver de estratégia de mesclagem do Git.

Escrita de estratégias de mesclagem

Além de usar uma das estratégias de mescla de compilações fornecidas, você também pode escrever suas próprias estratégias. As estratégias devem seguir uma interface padrão. Você deve escrever uma função de estratégia que pegue versões de um arquivo do existing-bundle, do proposed-bundle e do ancestor-bundle, e mesclá-las 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/**',
            ],
          },
        ],