Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Utilizzo di strategie di unione per generare pacchetti e specificare file

È possibile utilizzare strategie di unione per generare pacchetti con risintesi e specificare file per gli aggiornamenti della gestione del ciclo di vita dei blueprint personalizzati. Sfruttando le strategie resythensis e merge, è possibile gestire gli aggiornamenti e controllare quali file vengono aggiornati durante le distribuzioni. Puoi anche scrivere strategie personalizzate per controllare il modo in cui le modifiche vengono unite ai progetti esistenti. CodeCatalyst

Generazione di file con risintesi

Resynthesis può unire il codice sorgente prodotto da un blueprint con il codice sorgente generato in precedenza dallo stesso blueprint, permettendo la propagazione delle modifiche a un blueprint ai progetti esistenti. Le unioni vengono eseguite dalla funzione tra i pacchetti di output del blueprint. resynth() Resynthesis genera innanzitutto tre pacchetti che rappresentano aspetti diversi del blueprint e dello stato del progetto. Può essere eseguito manualmente localmente con il yarn blueprint:resynth comando, che creerà i bundle se non esistono già. L'utilizzo manuale dei pacchetti ti consentirà di simulare e testare localmente il comportamento della risintesi. Per impostazione predefinita, i blueprint eseguono solo la risintesi tra i repository sottostanti, src/* poiché solo quella parte del pacchetto è in genere sotto il controllo del codice sorgente. Per ulteriori informazioni, consulta Risintesi.

Ogni pacchetto viene creato durante una fase di risintesi a cui è possibile accedere dalla classe blueprint sotto. this.context.resynthesisPhase

L'unione a tre vie viene applicata prendendo la differenza tra ancestor-bundle e proposed-bundle e aggiungendola a per generare il. existing-bundle resolved-bundle Tutte le strategie di unione risolvono i file in. resolved-bundle Resynthesis risolve la portata di questi pacchetti con le strategie di fusione del progetto resynth() e produce il pacchetto risolto a partire dal risultato.

Utilizzo di strategie di fusione

È possibile utilizzare una strategia di fusione fornita dalla libreria Blueprints. Queste strategie forniscono modi per risolvere gli output e i conflitti dei file menzionati nella sezione. Generazione di file con risintesi

Per visualizzare il codice sorgente per le strategie di fusione, consulta il repository open source. GitHub

Specificazione dei file per gli aggiornamenti della gestione del ciclo di vita

Durante la risintesi, i blueprint controllano il modo in cui le modifiche vengono unite in un archivio di origine esistente. Tuttavia, potresti non voler inviare aggiornamenti a ogni singolo file del tuo blueprint. Ad esempio, il codice di esempio come i CSS fogli di stile è pensato per essere specifico del progetto. La strategia di unione a tre vie è l'opzione predefinita se non si specifica un'altra strategia. I blueprint possono specificare quali file possiedono e quali no specificando le strategie di unione sulla struttura del repository stesso. I blueprint possono aggiornare le proprie strategie di fusione e le strategie più recenti possono essere utilizzate durante la risintesi.

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

È possibile specificare più strategie di fusione e l'ultima strategia ha la precedenza. I file scoperti sono di default three-way-merge simili a Git. Il MergeStrategies costrutto fornisce diverse strategie di fusione, ma puoi scriverne di tue. Le strategie fornite aderiscono al driver di strategia git merge.

Scrittura di strategie di fusione

Oltre a utilizzare una delle strategie di build merge fornite, puoi anche scrivere le tue strategie. Le strategie devono aderire a un'interfaccia strategica standard. È necessario scrivere una funzione strategica che acquisisca le versioni di un file da existing-bundle proposed-bundleancestor-bundle, e e le unisca in un unico file risolto. Per esempio:

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 i file non esistono (non sono definiti), il percorso del file non esiste in quel particolare pacchetto di posizioni.

Esempio:

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