Skip to content

IMGOSPEL.COM

Imgospel

Da svn scaricare


  1. [Guida] Come scaricare progetti in formato SVN
  2. Programmazione/Subversion - Wiki di ubuntu-it
  3. Migrare da SVN a Git con Git-Externals

Tale copia è una normale cartella del filesystem che contiene i file scaricati dal server; in aggiunta, però contiene una serie di informazioni che il. Dopo aver installato Tortoise (non è necessario un client SVN separato), creare una nuova cartella vuota per il progetto da qualche parte e fare clic con il. [Guida] Come scaricare progetti in formato SVN Ecco il comando da digitare: La guida è stata realizzata da Andrea Busi per BubiDevs. TortoiseSVN richiede all'utente l'indirizzo remoto del repository da scaricare (nel Dando il via alla procedura, Tortoise SVN riversa nella cartella scelta il. Per installare Subversion, puoi crearlo da solo da una versione di codice sorgente o scaricare un pacchetto binario pre-costruito per il tuo sistema operativo.

Nome: da svn scaricare
Formato: Fichier D’archive
Sistemi operativi: MacOS. iOS. Windows XP/7/10. Android.
Licenza: Solo per uso personale (acquista più tardi!)
Dimensione del file: 55.26 MB

Introduzione Il framework symfony è un progetto Open Source da più di quattro anni ed è diventato uno dei framework PHP più popolari grazie alle molte feature offerte e all'ottima documentazione. Questa tradizione è iniziata molto presto. Questo libro descrive la creazione di una applicazione web passo-passo con il framework symfony dalle specifiche alla implementazione.

È rivolto ai principianti che vogliono imparare symfony, capire come funziona e anche conoscere le migliori pratiche di sviluppo web. L'applicazione da creare avrebbe potuto essere un'altra volta il motore di un blog.

Ma vogliamo usare symfony per un progetto utile. Manterremo il contenuto del progetto segreto per un altro giorno, dal momento che abbiamo abbastanza cose da fare oggi. Tuttavia diamogli un nome: Jobeet. Ogni giorno verranno aggiunte nuove feature all'applicazione, e sfrutteremo queste novità per introdurvi alle nuove funzionalità di symfony e alle good practice dello sviluppo web con symfony.

Se lavorate sotto piattaforma Microsoft, una delle soluzioni migliori prende il nome di TortoiseSVN: si tratta di un pratico programma, rilasciato con licenza open source, che vi consente di interagire con un server Subversion direttamente dal menu contestuale di Windows Explorer Vediamo come utilizzarlo. Una volta aver scaricato il file dalla nostra scheda , apritelo per iniziare la procedura guidata.

La procedura di setup non presenta passaggi particolarmente significativi: limitatevi a premere ripetutamente Avanti, accettare la licenza d'uso, specificare il percorso desiderato se quello di default non vi soddisfa e riavviare il sistema quando richiesto.

Subito dopo, vorrete probabilmente localizzare l'interfaccia in italiano: per farlo, scaricate e lanciate il pacchetto con la nostra lingua che trovate qui e avanzate fra le due schermate.

Portatevi poi su General, scegliete italiano dal menu a tendina e confermate con OK per completare la predisposizione del software Ora che il software è pronto, possiamo iniziare a lavorare.

[Guida] Come scaricare progetti in formato SVN

Eseguire il checkout Create una cartella in un un percorso a piacere: sarà quella adibita a contenere la copia di lavoro locale, sulla quale andrete effettivamente a ricevere, modificare, eliminare e creare i vari file di volta in volta. Fatevi quindi click con il pulsante destro del mouse e selezionate la voce SVN Ritira Il comando giusto per aggiornare la nostra copia locale è svn update, che vedremo nella prossima lezione.

Caricare le modifiche Abbiamo visto che nella nostra copia di lavoro esistono cartelle "speciali" che contengono le informazioni di versione. Grazie a questa localizzazione delle informazioni, gli altri file non hanno invece nulla di speciale e possono essere quindi modificati con qualsiasi strumento. Quindi, se stiamo parlando di codice o documentazione, possiamo aprire il file con il nostro editor preferito e lavorare normalmente — ad esempio, per questa guida, si sono utilizzati OpenOffice e NotePad.

Il client SVN infatti entra in gioco solo nel momento in cui tentiamo di caricare le modifiche con un comando commit. È confrontando i file della copia di lavoro, con la copia "originale" presente nelle cartelle nascoste, che il client SVN è in grado di determinare quali file avete cambiato e quindi quali modifiche sono da caricare sul server.

Cambia invece, e dobbiamo tenerlo ben presente, la modalità di ridenominazione, spostamento, cancellazione e aggiunta di file e cartelle. Supponiamo infatti di spostare un file in una diversa cartella della nostra copia di lavoro senza usare il comando apposito, ma semplicemente trascinando il file con il mouse.

Al momento del commit, il client SVN si accorge che c'è un file in meno nella prima cartella e un file in più nella seconda cartella. Se invece usiamo il comando move, lo spostamento del file verrà registrato come modifica e trasmesso al repository, con due evidenti vantaggi: il file porterà con sè lo storico delle proprie modifiche anche nella nuova posizione; lo spostamento, come qualunque modifica, potrà essere annullato semplicemente ritornando a una revisione precedente.

È obbligatorio tuttavia specificare un messaggio di commit, tipicamente usato per descrivere il tipo di modifiche apportate. È arrivato il momento di provare a caricare le modifiche alla guida effettuate dopo il primo checkout.

Clicchiamo con il tasto destro sulla cartella di lavoro locale e selezioniamo l'opzione SVN Commit. Ci viene mostrato l'elenco delle modifiche da apportare, con la possibilità di caricarne solo alcune.

Lasciamo tutto com'è e procediamo. Appare il solito elenco delle operazioni effettuate in questo caso vengono caricati gli ultimi file modificati , e infine il messaggio che indica che siamo arrivati alla revisione 2.

Update: aggiornare la copia locale Come abbiamo già visto, il checkout va effettuato solo per la prima estrazione. In seguito, per aggiornare la propria una copia di lavoro locale all'ultima versione presente sul repository si usa il comando: svn update Questo comando confronta il repository con la copia locale, ed effettua di conseguenze le seguenti operazioni: applica ai file locali eventuali modifiche effettuate agli stessi file sul repository aggiunge alla copia locale eventuali nuovi file e cartelle presenti sul repository; rimuove dalla copia locale eventuali file o cartelle rimossi dal repository; L'aggiornamento viene lanciato tipicamente all'inizio della propria sessione di lavoro, per garantirsi di avere a disposizione le ultime versioni di tutti i file.

Con un update portiamo in locale le ultime modifiche verificando anche eventuali conflitti e poi potremo procedere al commit. Nota: nonostante vengano effettuate in rapida sequenza, le azioni di update e di commit sono nettamente separate e non influiscono l'una sull'altra. In altre parole, quando si caricano le proprie modifiche, non vengono automaticamente scaricate le modifiche presenti sul repository; e al contrario, quando scarichiamo le ultime versioni dei file, non vengono caricate le proprie modifiche e anzi, potremmo decidere di buttarle quando ci accorgessimo che qualcun altro le ha già fatte meglio di noi.

In ciascuna copia di lavoro, possono essere presenti file in stato "unversioned". Si tratta di file temporanei creati dagli editor, oppure di note personali o configurazioni locali del progetto, che non devono essere trasportate sul repository.

E' anche lo stato in cui si trovano eventuali nuovi file creati a mano prima di essere "ufficialmente" aggiunti al progetto con il comando svn add Tali file non impediscono la normale operatività, ma per il client SVN rimangono delle anomalie da segnalare.

Cancellazione di una copia di lavoro locale Se una copia di lavoro locale non ci serve più, magari perchè frutto di un test di estrazione, perchè volevamo solo verificare un file, o perchè l'abbiamo involontariamente pasticciata e quindi dobbiamo ricrearla, possiamo eliminarla semplicemente cancellando la cartella corrispondente.

Ovviamente eventuali modifiche locali andranno perse, quindi è opportuno farlo solo per una buona ragione, come quelle sopraelencate. Soprattutto è importante non cancellare una copia di lavoro solo perchè è un po' che non la guardiamo e non abbiamo idea di quanto sia aggiornata e di cosa contenga.

Per questo lasciamo fare a SubVersion, altrimenti cosa l'abbiamo installato a fare? Con pochi semplici comandi siamo in grado rapidamente di sapere quali sono le modifiche locali di qualsiasi copia di lavoro, nonché di aggiornarla all'ultima versione e di avere un rapporto dettagliato degli eventuali conflitti. Navigare tra le revisioni Un repository appena creato è inizialmente vuoto, e si trova alla revisione 0.

Ogni volta che sul server viene caricata anche una sola modifica, l'intero albero aumenta di una revisione. Ad esempio, come abbiamo visto, l'importazione di un progetto ha portato il repository alla revisione 1, e allo stesso modo, ogni volta che abbiamo eseguito un commit la revisione è aumentate di uno. È importante capire che la revisione si applica a tutto l'albero: si tratta di una istantanea del contenuto dei file ma anche del loro nome, della loro posizione, e delle cartelle esistenti.

Ogni volta che viene caricata una qualsiasi modifica, a uno qualsiasi dei file, viene effettuata una nuova instantanea e tutti i file anche quelli non modificati vengono portati alla nuova revisione. Non c'è da stupirsi quindi se alcuni file rimangono uguali tra le diverse revisioni: evidentemente non erano oggetto di modifica, ma sono stati comunque portati alla nuova revisione.

Esistono anche della parole chiave per indicare revisioni "speciali": HEAD, indica l'ultima revisione presente nel repository. È la revisione implicitamente utilizzata quando non ne viene specificata una BASE, indica la revisione "originale" presente sulla propria copia di lavoro.

Programmazione/Subversion - Wiki di ubuntu-it

Si riferisce quindi sempre alla copia di lavoro locale: permette sostanzialmente di identificare la revisione creata con l'ultimo commit andato a buon fine PREV, indica la revisione immediatamente precedente a COMMITTED È possibile anche specificare una data per riferirsi a una versione, usando parentesi graffe. Nota: se si specifica una data senza specificare l'ora es.

Per esaminare temporaneamente una diversa revisione, dobbiamo ricordare di effettuare checkout in una cartella diversa rispetto a quella che ospita la nostra copia di lavoro corrente. Creiamo quindi una copia di lavoro temporanea che, una volta esaminata, possiamo tranquillamente cancellare. Lavorare sullo storico Subversion è un sistema di versioning, cioè mantiene un archivio storico di tutte le versioni dei file.

Esaminiamo i comandi di che ci permettono di agire sulle versioni, dalla visualizzazione dele modifiche effettuate, al confronto tra versioni differenti. Verificare lo storico svn log ci permette di visualizzare i messaggi di log associati a una o più revisioni, ad esempio: svn log -r mostra i log delle revisioni dalla 5 alla 9 incluse.

Se usando questo comando si riceve un log vuoto, dobbiamo assicurarci di essere nella cartella principale del progetto e non in una sottocartella. Se specifichiamo una sola revisione, viene effettuato un confronto tra la nostra copia di lavoro e la revisione indicata: svn diff -r 5 In TortoiseSVN, il comando svn log è diventato l'opzione show log, che mostra l'elenco delle revisioni disponibili.

Se eseguiamo questo comando su uno specifico file, possiamo poi selezionare due tra le revisioni mostrate, cliccare con il tasto destro e selezionare l'opzione compare revisions per eseguire l'equivalente del comando svn diff.

Ripristinare una revisione precedente Le operazioni esaminate finora ci permettono di vedere le modifiche effettuate, sia quelle locali e non ancora caricate sul repository, sia quelle delle varie revisioni. Con queste operazioni possiamo procedere manualmente a correggere eventuali modifiche fatte per errore, e poi caricare la copia corretta sul server.

Tale metodo è fornito dal comando svn merge. Usato da linea di comando, svn merge ha tre possibili forme, a seconda che si vogliano confrontare due diversi repository, oppure due revisioni del repository dal quale abbiamo estratto la nostra copia di lavoro attuale, oppure una specifica revisione di un repository e una copia di lavoro.

Il comando è molto potente, ma bisogna fare attenzione alla sintassi giusta. È utile consultare il manuale ufficiale di SubVersion per una spiegazione dettagliata delle varie opzioni ed esempi. Fortunatamente, con TortoiseSVN esiste una "scorciatoia" che ci permette di realizzare l'opzione più semplice, ovvero prendere una vecchia revisione farla diventare HEAD.

Clicchiamo con il tasto destro su uno specifico file o cartella, oppure sulla cartella principale del progetto nel caso in cui si voglia ripristinare l'intero albero ; selezioniamo l'opzione show log, scorriamo l'elenco fino a trovare la revisione che ci interessa e, infine, clicchiamo con il tasto destro sull'opzione Revert to this revision.

In questo modo, anziché esportare direttamente la revisione, il client applica "al contrario" alla copia locale le modifiche fino alla revisione indicata. Conflitti e modifiche locali Risolvere i conflitti Come abbiamo accennato, SubVersion è in grado di accorgersi se le modifiche effettuate da diversi utenti si sovrappongono. In tal caso ci segnala il conflitto e ci chiede di risolverlo. Vengono inoltre creati nella nostra copia di lavoro altri tre file temporanei: nomefile.

Per risolvere il conflitto abbiamo quindi diverse strade: unire a mano le modifiche, sfruttando i marcatori inseriti da SubVersion sovrascrivere il file che crea conflitto con uno dei tre file temporanei sopra elencati usare il comando svn revert per annullare tutte le modifiche locali Se scegliamo la strada 1 o la 2, che sono modifiche manuali, dovremo poi avvertire SVN dell'avvenuta risoluzione usando il svn resolved nomefile, che ovviamente in TortoiseSVN diventa l'opzione resolved disponibile cliccando con il tasto destro sul file in questione.

Esaminare i cambiamenti locali Ci sono diversi comandi che ci permettono di avere informazioni sulla nostra copia di lavoro locale senza nemmeno bisogno di collegarsi al repository. Per verificare lo stato della copia di lavoro è disponibile il comando svn status, che ci permette tra le altre cose di sapere quali file sono stati modificati, aggiunti, cancellati; in pratica ci offre una anteprima di quello che succederebbe con un commit.

Per visualizzare nel dettaglio le modifiche apportate a uno specifico file rispetto alla revisione BASE, è disponibile il svn diff. Infine, per annullare le modifiche locali effettuate e tornare alla revisione BASE, è disponibile il comando svn revert. Non ci resta che provare.

Lo eseguiamo e visualizziamo l'elenco: ho un file in stato modified, cioè in corso di modifica e un file in stato unversioned. Se cliccchiamo con il tasto destro sul file in stato modified, possiamo selezionare l'opzione Compare with base, che corrisponde al comando svn diff.

Chiudiamo ora tutte le finestre di dialogo, torniamo al nostro filesystem e clicchiamo con il tasto destro sulla cartella di lavoro: tra le altre è presente l'opzione revert. Per il momento non eseguiamo, non abbiamo ancora effettuato un commit e se perdiamo le modifiche dobbiamo rifare tutto il lavoro. I lock e le sovrapposizioni Nelle prime lezioni abbiamo introdotto il modello di versionamento Copy-Modify-Merge e abbiamo visto come questo non possa essere indistintamente applicato a tutti i file.

In particolare la fusione di diverse modifiche non è disponibile per i file non-mergeable immagini, o file binari. Subversion non interpreta il lock in maniera particolarmente rigida. L'idea di Subversion è che il blocco sia uno strumento di comunicazione più che di protezione: deve avvisare gli altri utenti che stiamo effettuando modifiche esclusive, ma si suppone che un collaboratore possa avere buoni motivi per rompere il lock e proseguire con le modifiche, e quindi glielo si lascia fare.

Tecnicamente non viene effettuata nessuna modifica al file: il lock viene creato come file separato in una apposita cartella del repository, come vedremo più avanti quando ci occuperemo dell'amministrazione del repository.

Nella guida ufficiale è espresso chiaramente come Subversion non possa sostituire il dialogo, la corretta pianificazione dei lavori e gli standard di nomenclatura. Anzi, il programma riesce in vari modi a migliorare la nostra cooperazione, soprattutto se siamo un team disorganizzato: blocca le sovrapposizioni più evidenti modifiche diverse alle stesse righe di codice ; aiuta a scoprire rapidamente dove sono tali sovrapposizioni e a risolverle; permette facilmente e rapidamente di "fare ordine" in eventuali sovrapposizioni, tornando a versioni precedenti, annullando le modifiche locali, o confrontando varie revisioni dei file.

Quindi, Subversion non sostituisce una efficente organizzazione interna, ma è uno strumento che ci aiuta a implementarla e mantenerla. Gestione avanzata dei progetti I rami branches Nei capitoli precedenti abbiamo esaminato le operazioni più comuni nell'utilizzo di Subversion; queste conoscenze possono bastare per un utilizzo basilare e soddisfare la maggior parte delle esigenze. Ad esempio chi lavora da solo e usa il prodotto solo come archivio e storico delle modifiche, potrebbe anche non aver mai bisogno di utilizzare le funzionalità avanzate di Subversion.

Nelle prossime lezioni approfondiremo la gestione di diversi rami di uno stesso progetto, una caratteristica comune a tutti i software di controllo di versione.

Un ramo nasce semplicemente come copia del progetto principale; ne condivide la storia fino al momento della separazione, ma procede poi — temporaneamente o per sempre, a seconda delle esigenze, su un binario separato. I diversi rami rimangono comunque in qualche modo collegati, infatti è possibile trasportare le modifiche da un ramo all'altro o addirittura fondere completamente due o più rami.

I motivi che portano all'uso dei rami sono tipicamente due: La creazione di diverse versioni dello stesso progetto, da mantenere separate. Ad esempio, nel caso di questa guida, potremmo volerne realizzare una versione destinata al sistemista che si occupa di configurare e gestire il server e un'altra destinata al programmatore. Alcune parti saranno in comune; altre sarebbero presenti solo in uno dei due rami; altre ancora sarebbero presenti in entrambi, ma con un contenuto leggermente modificato.

In questo caso dovremmo creare due rami separati, destinati a rimanere tali, trasportando dall'uno all'altro le modifiche che riguardano le parti comuni. La creazione di un ambiente di sviluppo temporaneo, destinato prima o poi a essere fuso con il ramo principale. Si crea quindi un ramo secondario nel quale viene ospitata la versione di sviluppo. Quando questa versione sarà completa, i due rami saranno riuniti in uno solo.

Specialmente nel secondo caso, è importante tenere sincronizzati spesso i due rami. Se infatti questo non avviene, i due binari si allontanano sempre di più e quando sarà il momento di unirli avremo un numero ingestibile di conflitti.

E oltre ai conflitti veri e propri intesi come sovrapposizioni delle modifiche è sempre possibile che ci siano altre modifiche, in punti diversi dei file, che in qualche modo ci coinvolgono e ci costringono ad adattare il nostro codice. In questo caso, il dialogo tra gli sviluppatori è fondamentale. Creazione di un ramo Partiamo innanzitutto con una nota sulla denominazione delle cartelle del nostro progetto. Se prevediamo che il nostro repository possa avere più rami, è bene inserire al primo livello del repository due sottocartelle separate, una che contiene il ramo principale e una che contiene gli altri rami.

Per convenzione, la cartella del ramo principale viene chiamata trunk e la cartella dedicata ai rami viene tipicamente chiamata branches. Si tratta solo di convenzioni, dunque possiamo sostituire i nomi a nostro piacimento, ma rispettare degli standard di nomenclatura usati in tutto il mondo non è una cattiva idea.

Per Subversion non esiste realmente il concetto di rami separati: se creiamo una copia di una cartella, per lui è semplicemente questo: la copia di una cartella. Siamo noi che, potendo fare checkout, update e commit di singole cartelle del repository, lo consideriamo un ramo separato e lavoriamo solo su quello.

Ecco perchè è importante separare le cartelle e dargli una nomenclatura esplicativa: perchè ci serve per assegnare il concetto di "ramo" a quelle che per Subversion sono semplicemente cartelle diverse di uno stesso progetto, che — come tutti gli elementi copiati — condividono lo storico fino al momento della copia.

Migrare da SVN a Git con Git-Externals

Trattandosi sempre di uno stesso repository, inoltre, la numerazione delle revisioni rimane comune tra i rami: ad esempio se effettuiamo un commit sul ramo principale e generiamo la revisione 10, il commit successivo sul ramo secondario produrrà la revisione Spostare un repository già creato Se abbiamo già messo del contenuto nel repository e vogliamo spostarlo per creare la struttura adeguata ad ospitare rami separati, possiamo utilizzare il comando svn move: svn move URL1 URL2 Con TortoiseSVN, possiamo avviare il Repository Browser e utilizzare l'opzione Create folder per creare la struttura che ci interessa, e poi trascinare direttamente con il mouse i file già esistenti nella nuova locazione.

Questa operazione non richiede particolare attenzione per essere effettuata, ma è fondamentale che tutti gli utenti ne siano informati. Unire i cambiamenti Ci sono diversi momenti in cui risulta necessario unire i cambiamenti tra diversi rami. Come abbiamo già detto, è bene mantenerli sincronizzati di tanto in tanto, per evitare di far crescere a dismisura il numero di conflitti.

Inoltre, se si tratta dell'implementazione di nuove caratteristiche, prima o poi dovranno essere fuse con il ramo principale. Il trasporto delle modifiche tra rami viene effettuato con il comando svn merge.

Nota: dalla versione 1. Merge basilare La situazione più frequente è quella in cui l'utente che sta lavorando sul ramo secondario vuole trasportare sulla propria copia di lavoro le modifiche effettuare sul ramo principale, per affrontare e risolvere per tempo non solo i conflitti — cioè le vere e proprie sovrapposizioni di modifiche — ma anche altri cambiamenti che potrebbero richiedere adattamenti del proprio codice.

Il comando merge è piuttosto potente. Tutto quello che dobbiamo fare noi è assicurarci, prima di eseguirlo, che tutti i cambiamenti locali sulla nostra copia di lavoro siano stati caricati con un commit sul ramo corrispondente cioè il ramo secondario e dopo l'esecuzione, esaminare con calma le modifiche apportate col comando svn diff. Merge successivi L'operazione di sincronizzazione sopra descritta non avviene una volta sola: se il lavoro sul ramo secondario dura molto, sarà utile ripeterla frequentemente.

Prima della versione 1. Nelle ultime versioni di SubVersion invece le informazioni di merge vengono salvate come proprietà dei rami, in particolare, viene mantenuta l'ultima revisione a cui ci si è sincronizzati. Ricordiamo che per Subversion i rami sono normali cartelle, quindi possono avere associate delle proprietà dette anche metadati. Il comando merge sfrutta questa possibilità per salvare una proprietà mergeinfo che verrà esaminata nei successivi merge, per evitare di riportare più volte gli stessi cambiamenti.

Quindi invocando in seguito lo stesso comando usato per la prima sincronizzazione verranno uniti solo i cambiamenti successivi. Fusione di due rami Uno dei due motivi principali — e probabilmente il più frequente — per creare rami separati è quello di avere un ambiente di sviluppo isolato temporaneo per realizzare una serie di importanti modifiche, come l'aggiunta di nuove funzionalità, che andranno poi unite al ramo principale.

Supponiamo di aver fatto le cose per bene, e esserci tenuti frequentemente sincronizzati con il ramo principale per avere a disposizione le modifiche fatte da altri. Quello che ci rimane da fare ora è l'opposto: riportare le nostre modifiche. Il primo consiglio è quello di chiedere a tutti i collaboratori di sospendere temporaneamente i commit sul repository.

Infatti, le prime volte che fonderemo diversi rami potremmo metterci un po', e per essere certi di fare tutto bene, è meglio evitare sovrapposizioni con altre modifiche su uno qualsiasi dei due rami.