Nessun risultato. Prova con un altro termine.
Guide
Notizie
Software
Tutorial

Rails e Subversion

Mantenere il controllo sulle versioni di un nuovo progetto Rails con Subversion
Mantenere il controllo sulle versioni di un nuovo progetto Rails con Subversion
Link copiato negli appunti

Subversion (SVN) è uno dei più diffusi sistemi VCS (Version Control System), ovvero uno strumento che consente di tenere traccia, modifica dopo modifica, di tutti i cambiamenti apportati ai file contenuti in un progetto come codice sorgente, documentazione o pagine Web.

L'utilizzo di un sistema VCS, anche conosciuto come SCM (Source Code Management), è un requisito essenziale per sviluppare software in modo efficace, produttivo e sicuro. Ci vorrebbe ben più di un articolo per affrontare in modo completo l'argomento SCM e, poiché il tema esula dall'obiettivo di questo articolo, per approfondimenti vi consiglio la lettura del libro Shipit!, A Practical Guide toSuccesful Software Projects dove sono certo che troverete risposte a molte delle vostre domande.

In questo articolo vedremo come creare un nuovo progetto Rails e come eseguire l'importazione di tutti i file in un nuovo repository SVN configurando le opportune proprietà affinché i file di log e temporanei siano opportunamente ignorati da Subversion.

Requisiti

L'articolo è organizzato come mini-tutorial e fornisce passo passo tutte le indicazioni necessarie, corredate da esempi . Tuttavia, per comprendere ed applicare le indicazioni seguenti, è necessario disporre dei seguenti prerequisiti:

  • Conoscenza delle caratteristiche di Subversion (SVN) e dei principali comandi
  • Conoscenza delle basi di Ruby e Ruby on Rails
  • Disponibilità (in locale o remoto) di un repository SVN dove importare il progetto Rails
  • Subversion (1.4.x) client installato ed attivo da commandline o con eventuali GUI (es. TortoiseSVN per Windows)
  • Ruby e Rails (l'esempio usa rispettivamente Ruby 1.8.6 e Rails 2.0.2)

Tutte le operazioni seguenti fanno riferimento a istruzioni digitate direttamente da commandline. Per gli utenti Mac OSX e Linux questo non dovrebbe rappresentare un problema, gli utenti Windows possono utilizzare il Prompt del DOS per eseguire gli stessi comandi.

I comandi di Rails e SVN sono universali indipendentemente dal sistema operativo. Al contrario, i comandi di sistema (copia cartella, sposta cartella, etc.) potrebbero variare a seconda dell'ambiente in uso. La maggior parte delle operazioni eseguite da console possono essere eseguite senza problemi anche attraverso il classico Esplora Risorse (su Windows) o qualsiasi altro file manager a disposizione.

Utente esperto? Gli utenti con una discreta padronanza nell'uso dei comandi da shell, specialmente quelli relativi aRails e SVN, possono saltare direttamente al termine di questo articolo per consultare un breve riepilogo dei comandi necessari a completare il tutorial privi dei commenti che accompagnano ogni step.

Ad ogni modo, consiglio comunque una lettura delle sezioni seguenti per essere certi di comprendere al meglio ogni singolo passo del tutorial.

Creazione del progetto Rails

Ora che abbiamo esaurito tutte le necessarie premesse, entriamo nel vivo del tutorial. Come prima cosa è necessario procedere con la creazione di un nuovo progetto Rails, che chiameremo htmlit. Individuiamo una posizione temporanea dove collocare il progetto in fase di creazione, ad esempio il Desktop, e creiamo una cartella temporanea con un nome di fantasia, ad esempio svnrepos.

$ cd Desktop
$ mkdir svnrepos

Ora posizioniamoci all'interno della cartella e creiamo il nostro nuovo progetto Rails, come di consueto, con il comando rails <nomeprogetto>.

$ cd svnrepos
$ rails htmlit
create
createapp/controllers
createapp/helpers
createapp/models
    ...

A questo punto la cartella iniziale svnrepos conterrà una nuova sottocartella, chiamata htmlit, con la struttura base di un nuovo progetto Rails.

Creazione della struttura base di un repository SVN

Ogni repository SVN, normalmente, è composto da 3 cartelle principali chiamate

  • trunk
  • branches
  • tags

Ogni cartella ha un suo preciso compito, ampiamente documentato nel libro Version Control with Subversion. Il prossimo passo consiste quindi nell'uniformare la nostra struttura a quella di un repository SVN.

In realtà non c'è molto lavoro da fare. Come prima cosa, torniamo nella cartella svnrepos che, a tutti gli effetti, corrisponderà alla root del nostro nuovo repository. Rinominiamo la sottocartella htmlit in trunk.

$ mv htmlit trunk

Ora creiamo le cartelle tags e branches.

$ mkdir tags
$ mkdir branches

A questo punto la nostra cartella svnrepos dovrebbe contenere le 3 directory tipiche di un repository SVN, dove trunk è in realtà il nostro progetto Rails creato in precedenza.

Preparazione del progetto Rails per l'importazione

Prima di procedere con l'importazione del progetto Rails nel repository SVN è necessario rimuovere le cartelle ed i file che non vogliamo tenere sotto controllo. Ad esempio, è abitudine ignorare i file di log ed i file temporanei. Inoltre, per ragioni di sicurezza, anche il file finale di configurazione del database non viene quasi mai salvato nel repository.

Ci spostiamo dunque nella cartella trunk del progetto e, in ordine, rimuoviamo il contenuto delle cartelle log e tmp.

$ cd trunk
$ rm -r log/*
$ rm -r tmp/*

Ora rinominiamo il file di configurazione del database in database.sample.yml.

$ mv config/database.yml config/database.sample.yml

A questo punto siamo pronti per procedere con l'importazione del nostro nuovo progetto nel repository subversion.

Importazione del progetto Rails in Subversion

Spostiamoci nella cartella svnrepos creata inizialmente ed eseguiamo il comando svn import per importare il contenuto della nostra directory locale nel repository SVN.

Nel nostro esempio, queste sono le credenziali per il repository SVN:

  • url: svn://localhost/htmlit
  • username: weppos
  • password: letmein
$ cd ..
$ svn import . svn://localhost/htmlit -m "Initial import" --username weppos

A seconda della configurazione del repository potrebbe essere necessario digitare la password associata all'username indicato. A questo punto, se l'importazione è andata a buon fine, SVN dovrebbe rispondere con un messaggio del tipo

$ Committed revision 1

Configurazione delle proprietà SVN

Siamo quasi alla fine ma, prima di cominciare a lavorare con il nostro nuovo repository, sono ancora necessarie alcune configurazioni per evitare che i file precedentemente rimossi vengano aggiunti automaticamente al controllo di versione da IDE troppo zelanti o programmatori disattenti.

Innanzi tutto assicuriamoci di lavorare su una copia fresca del repository appena creato. Cancelliamo quindi la cartella svnrepos ed eseguiamo un checkout della cartella trunk direttamente dal repository.

$ cd ..
$ rm -rf svnrepos
$ svn co svn://localhost/htmlit/trunk htmlit --username weppos
$ cd htmlit

Ignoriamo il file di configurazione del database, la cartella log e tmp.

$ svn propset svn:ignore database.yml config/
$ svn propset svn:ignore "*" log/
$ svn propset svn:ignore "*" tmp/

Poi, per sicurezza, ignoriamo tutti gli eventuali file database SQLite all'interno della cartella db.

$ svn propset svn:ignore "*.db" db/
$ svn propset svn:ignore "*.sqlite3" db/

Aggiorniamo il repository con le modifiche.

$ svn commit -m "* Ignored /log, /tmp folders and SQLite databases"

Infine, creiamo una copia del file di configurazione del database e rinominiamola database.yml affinché Rails funzioni correttamente.

$ cp config/database.sample.yml config/database.yml

Finito! Ora possiamo lavorare con il nostro nuovo progetto Rails sfruttando a pieno le potenzialità di un sorgente sotto controllo di versione.

Riepilogo dei comandi

Ecco il riepilogo dei comandi indicati nelle precedenti sezioni, privi dei vari commenti ed informazioni di contorno.

Creazione di una cartella temporanea e del progetto Rails

$ mkdir svnrepos
$ cd svnrepos
$ rails htmlit

Creazione della struttura base di un repository

$ mv htmlit trunk
$ mkdir tags
$ mkdir branches

Preparazione del progetto

$ cd trunk
$ rm -r log/*
$ rm -r tmp/*
$ mv config/database.yml config/database.sample.yml

Importazione in Subversion

$ cd ..
$ svn import . svn://localhost/htmlit -m "Initial import" --username weppos

Checkout del repository

$ cd ..
$ rm -rf svnrepos
$ svn co svn://localhost/htmlit/trunkhtmlit --username weppos
$ cd htmlit

Configurazioni finali

$ svn propset svn:ignore database.yml config/
$ svn propset svn:ignore "*" log/
$ svn propset svn:ignore "*" tmp/
$ svn propset svn:ignore "*.db" db/
$ svn propset svn:ignore "*.sqlite3" db/

Aggiornamento del repository

$ svn commit -m "* Ignored /log, /tmp folders and SQLite databases"

Creazione del file di configurazione del database

$ cp config/database.sample.yml config/database.yml

Conclusioni

Nonostante le apparenze, il procedimento sopra descritto non è così complesso, soprattutto una volta che si conosce a fondo le caratteristiche e lo scopo di ciascuna cartella di un progetto Rails.

Tuttavia, anche una procedura semplice richiede del tempo. Per questo motivo, molti preferiscono codificare queste operazioni ripetitive in appositi script. Senza spostarci troppo dall'ambiente Rails, Rake è senza dubbio un alleato ideale per creare una procedura da lanciare con un solo click.

Quella di codificare le procedure più frequenti in task automatici è sempre un'eccellente abitudine.


Ti consigliamo anche