Utilizzo di strategie di unione per generare pacchetti e specificare file

Generazione di file con risintesi

Resynthesis può unire il codice sorgente prodotto da un blueprint con il codice sorgente precedentemente generato 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.

• existing-bundle- Questo pacchetto è una rappresentazione dello stato del progetto esistente. Questo è costruito artificialmente dal calcolo di sintesi per fornire al modello un contesto su cosa c'è nel progetto in cui viene implementato (se non altro). Se qualcosa esiste già in questa posizione quando si esegue la risintesi in locale, verrà ripristinato e considerato come una simulazione. Altrimenti, verrà impostato sul contenuto di. ancestor-bundle

• ancestor-bundle- Questo è il pacchetto che rappresenta l'output del progetto se è stato sintetizzato con alcune opzioni e/o versioni precedenti. Se è la prima volta che questo blueprint viene aggiunto a un progetto, allora l'antenato non esiste, quindi è impostato sugli stessi contenuti di. existing-bundle A livello locale, se questo pacchetto esiste già in questa posizione, verrà rispettato come simulato.

• proposed-bundle- Questo è il pacchetto che simula il modello se è stato sintetizzato con alcune nuove opzioni e/o versioni. Questo è lo stesso pacchetto che verrebbe prodotto dalla funzione. synth() A livello locale, questo pacchetto viene sempre sovrascritto.

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

• resolved-bundle- Questo è il pacchetto finale, che è una rappresentazione di ciò che viene impacchettato e distribuito in un progetto. CodeCatalyst È possibile visualizzare quali file e differenze vengono inviati ai meccanismi di distribuzione. Questo è l'output della resynth() funzione che risolve le fusioni tra gli altri tre pacchetti.

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

• alwaysUpdate- Una strategia che si risolve sempre nel file proposto.

• neverUpdate- Una strategia che si risolve sempre nel file esistente.

• onlyAdd- Una strategia che si risolve nel file proposto quando un file esistente non esiste già. Altrimenti, si risolve nel file esistente.

• threeWayMerge- Una strategia che esegue un'unione a tre vie tra i file predecessori esistenti, proposti e comuni. Il file risolto può contenere indicatori di conflitto se i file non possono essere uniti in modo pulito. Il contenuto dei file forniti deve essere codificato in UTF-8 affinché la strategia produca un output significativo. La strategia tenta di rilevare se i file di input sono binari. Se la strategia rileva un conflitto di fusione in un file binario, restituisce sempre il file proposto.

• preferProposed- Una strategia che esegue un'unione a tre vie tra i file predecessori esistenti, proposti e comuni. Questa strategia risolve i conflitti selezionando il lato del file proposto di ogni conflitto.

• preferExisting- Una strategia che esegue un'unione a tre vie tra i file predecessori esistenti, proposti e comuni. Questa strategia risolve i conflitti selezionando il lato del file esistente di ogni conflitto.

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 fogli di stile CSS deve essere specifico del progetto. La strategia di fusione 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/**',
            ],
          },
        ],