Come faccio a utilizzare un Git submodule con un Compositore libreria caricata?

Ho un Zend Framework 2 applicazione. Esso contiene alcune librerie di codice che contiene la logica di business e di alcuni altri programmi di utilità che sarà comune ad altre applicazioni che verranno creati successivamente.

Mia intenzione è quella di condividere tra i progetti di utilizzo di Compositore. La domanda è, come faccio a fare questo correttamente e ottimizzare lo sviluppo? Io quasi certamente bisogno di apportare modifiche e integrazioni alla biblioteca, dal di dentro l’altro progetto.

Ho provato a configurare vendor/stuff come git submodule contenente il pacchetto necessario, e fa riferimento primario composer.json come questo (ref):

"repositories": [
    {
        "type": "git",
        "url": "vendor/stuff"
    }
],
"require": {
    "stuff/library": "master"
},

Compositore non è in grado di caricare in questo modo. Si lamenta che il pacchetto non può essere trovato, presumibilmente perché è ignorando il fatto che la URL sia locale e relativa. Tecnicamente, non è necessario; il fornitore/roba cartella inizializzato separatamente tramite git submodule comandi.

InformationsquelleAutor bcmcfc | 2013-08-07

 

2 Replies
  1. 42

    Purtroppo* Compositore non supporta il sotto-moduli di Git, come l’obiettivo principale dell’autore è quello di fornire un simile inter-dipendenza di progetto funzionalità e sarebbe inutile tentare di replicare in sotto-moduli Compositore.

    Ho lo stesso problema che si sta tentando di risolvere, di sviluppo di una libreria e contemporaneamente sviluppare l’applicazione che utilizza la libreria. Ci sono un paio di modi per risolvere il problema semplicemente utilizzando il compositore.

    Creare un link simbolico per la directory della libreria

    Questo è il modo più veloce e più sporco modo di farlo. Basta fare un compositore di aggiornamento per creare la directory appropriata per il libreria dei fornitori di directory, quindi sostituirlo con un link simbolico dalla vostra directory che contiene la libreria.

    Ovviamente questo non è grande come si può sovrascrivere accidentalmente codice che potrebbe essere modificato mediante l’esecuzione di compositore di aggiornamento.

    Utilizzare Compositore preferiscono opzione di origine

    Compositore ha la possibilità di scaricare il sorgente tramite un Git clone (--prefer-src) piuttosto che il download di un zipball (--prefer-dist) che è l’impostazione predefinita. Questo consente di modificare il codice sorgente all’interno della directory fornitori e quindi commettere tramite Git.

    ad esempio, Diciamo che avete un progetto che richiede, tra le altre biblioteche symfony/yaml che si desidera la correzione di un bug. Che cosa si potrebbe fare è:

    1. composer update – Questo permetterà di scaricare tutte le dipendenze del progetto.

    2. composer update symfony/yaml --prefer-source – Questo sarà ora di aggiornare solo il symfony/yaml directory nella directory fornitori.

    3. Risolvere il bug e quindi commettere tramite git.

    Utilizzare Compositore repository locale

    Il modo I —effettivamente— usato per lavoro quando sto sviluppando un progetto ed è requisito in tandem, è quello di utilizzare Compositori possibilità di impostare impostare in modo esplicito un repository di utilizzare per risolvere le dipendenze. ad esempio, se il codice è:

    /projects/library/
    /projects/project/
    

    Nel compositore di file per il vostro progetto di aggiungere il repository di ingresso:

    "repositories": [
        {
            "type": "vcs",
            "url": "/projects/library/"
        }
    ]
    

    Esecuzione composer update ora guardare il Git voci /progetti/library/a risolvere le dipendenze biblioteca preferenza a quelli elencati nel Packagist o altri repository.

    Questo significa che quando si vuole testare un cambiamento nella libreria di codice è necessario:

    1. Commesso, in modo che abbia un Git voce.

    2. Eseguire Compositore di aggiornamento nella directory del progetto, per ottenere la versione più recente.

    Ma si evita di dover spingere il commit di un repository esterno, che è un bene perché significa non spingendo il codice che non funziona, e questo significa che è possibile lavorare offline come Git commit non richiedono una connessione a internet.


    Anche se apparentemente il modo migliore di lavorare, è ancora una specie di pericoloso, in quanto è troppo facile accidentalmente il check-in una versione del compositore.json che fa riferimento alla directory locale, che, ovviamente, si romperà il progetto per tutti gli altri.

    Per evitare questo ho fatto un paio di piccoli script che ho) il backup del mio compositore.file json, ii) Aggiungere, in alcuni locali archivi, iii) eseguire composer update iv) Ripristinare il compositore.file json.

    localupdate.sh

    cp -f composer.json composer.json.bak
    php composerLocal.php
    composer update
    cp -f composer.json.bak composer.json
    

    composerLocal.php

    <?php
    
    $srcFile = file_get_contents("composer.json");
    $hackFile = file_get_contents("composer.local");
    $finalString = str_replace('"LOCALHACK",', $hackFile, $srcFile);
    file_put_contents("composer.json", $finalString);
    
    ?>
    

    compositore.locale

    "LOCALHACK",
    
    "repositories": [
        {
            "type": "vcs",
            "url": "/projects/library1"
        },
        {
            "type": "vcs",
            "url": "/projects/library2"
        }   
    ],
    

    E poi posto "//": "LOCALHACK", da qualche parte nei tuoi progetti composer.json file. In esecuzione localupdate.sh ora sicuro non un compositore di aggiornamento contro il repository locale, senza possibilità di commettere una versione cattiva del compositore.json.

    Clonare te con Git

    Questo è come tendo a lavorare ora:

    i) Compositore di aggiornamento del progetto
    ii) Andare nella directory fornitori ed eliminare la biblioteca che vorrei essere in via di sviluppo, allo stesso tempo.
    iii) Git clone da qualsiasi repo lo sviluppo della biblioteca, nell’apposita directory fornitori.

    Compositore capisce git repos, in modo da non sovrascrivere un git clonato directory, anche se non sembrano avere un po ‘ confuso circa la modifica del compositore.json della biblioteca).

    Facendo il git clone di te stesso, ti dà il controllo completo su ciò che viene installato, e permette di installare da un repo compositore che non conosce, o senza tag di versione, senza dover modificare il compositore.json nel progetto.

    Che è la caratteristica chiave di fare il git clone di te stesso; non toccare il compositore.json del progetto, è completamente sicuro, senza possibilità di verifica e di compositore.json che è stato modificato per l’uso di locali/custom repos.

    • Modifica – 6 Settembre 2014

    La convalida per il compositore.json file è stato serrato e non è più possibile avere un "//": "LOCALHACK" voce nel file. Che è un altro motivo per cui il Compositore ragazzi di non avere il controllo delle versioni per il Compositore progetto è matto.

    * In realtà, penso che sotto-moduli di Git sono un muto, muto, muto di attuazione per ‘risolvere’ un problema difficile in un modo che solo provoca più problemi lungo la strada, e così il Compositore non li supporta è il modo più ‘fortunati’ che ‘sfortunato’. Ovviamente le altre persone fanno, e sono felice con loro, in modo che è solo la mia opinione, l’uomo, ma se si sta utilizzando il Compositore non dovreste avere bisogno per sotto-moduli.

    • A questo punto “Uso Compositore preferiscono fonte opzione” rimosso il mio dilemma nel passare al compositore. Grazie per la risposta la questione ampiamente!
    • +1 a “, Se si utilizza il compositore non è necessario sotto-moduli.”
    • Ho avuto problemi di editing le dipendenze installate dal compositore utilizzando globale di installazione perché stava impostando la proprietà di file come root e la mia IDE non dispone di autorizzazioni. Ho risolto il problema spostando il compositore di ~/bin/composer e tra ~/bin il mio PERCORSO.
    • Ho finito di fare qualcosa di simile a LOCALHACK, tranne che è uno script che unisce il JSON e trigger compositore contro un file temporaneo.
  2. 2

    Compositore che ha un autoload funzione di mappatura che è molto utile per fare quello che stai chiedendo se la vostra libreria di seguire la PSR-x standard. È anche possibile caricare in automatico non-psr-x librerie a seguito di una procedura simile.

    Qui il riferimento: https://getcomposer.org/doc/04-schema.md#autoload

    Facciamo un esempio (supponendo che la vostra libreria segue la PSR-4)

    Si supponga di avere clonato il submodule nella cartella lib/il-privato-git-repo.

    Tutto quello che dovete fare è aggiungere al vostro composer.json file autoload sezione:

    {
        "name": "YourNamespace/YourApplicationName",
        "description": "Describe your library",
        "license": "Your licen",
        "keywords": ["some","keywords"],
        "authors": [
            {
                "name": "Adamo Aerendir Crespi",
                "email": "[email protected]"
            }
        ],
        "require": {
            "joomla/framework": "*@stable"
        },
        "require-dev": {
            "phpunit/phpunit": "*@stable"
        },
        "autoload": {
            "psr-4": {
                "YourNamespace\\YourSubmodule\\": "lib/your-private-git-repo/src"
            }
        }
    }

    Nota che le linee formano la sesta riga dal basso del codice

        "autoload": {
            "psr-4": {
                "YourNamespace\\YourSubmodule\\": "lib/your-private-git-repo/src"
            }
        }

    Ora aggiornare il Compositore

    php composer.phar update

    In questo modo Compositore aggiornare il caricamento di file tra cui il submodule troppo.

    Tutto fatto: ora il tuo submodule è caricato automaticamente da Compositore.

    Spero che questo vi aiuterà.

Lascia un commento