Les Systèmes de contrôle de version sont des paquetages qui peuvent enregistrer de multiples versions d'un fichier source, habituellement en enregistrant les parties inchangées du fichier une seule fois. Les systèmes de contrôle de version enregistrent aussi des informations historiques comme la date de création de chaque version, leur créateur, et une description des changements dans cette version.
L'interface de contrôle de version d'Emacs est appelé VC. Ses commandes fonctionnent avec trois systèmes de contrôle de version--RCS, CVS et SCCS. Le Projet GNU recommande RCS et CVS, qui sont des logiciels libres et disponibles auprès de la Free Software Foundation. Nous avons aussi du logiciel libre pour remplacer SCCS, appelé CSSC ; si vous utilisez SCCS et ne voulez pas faire le changement incompatible vers RCS ou CVS, vous pouvez passer à CSSC.
VC vous permet d'utiliser un système de contrôle de version depuis Emacs, en intégrant les opérations de contrôle de version avec l'édition. VC fournit une interface uniforme pour le contrôle de version, aisni quel que soit le système de contrôle de version utilisé, vous pouvez l'utiliser de la même manière.
Cette section fournit un aperçu général du contrôle de version, et décrit les systèmes de contrôle de version supportés par VC. Vous pouvez sauter cette section si vous êtes déjà familiers avec le système de contrôle de version que vous voulez utiliser.
VC fonctionne à cette heure avec trois systèmes de contrôle de version ou "back ends" différents : RCS, CVS et SCCS.
RCS est un système de contrôle de version libre disponible auprès de la Free Software Foundation. Il est peut-être le plus mature des back ends supportés, et les commandes de VC sont conceptuellement plus proches de RCS. Tout ce que vous pouvez faire avec RCS peut être fait à travers VC.
CVS est construit au dessus de RCS, et étend les possibilités de RCS, permettant une gestion des versions sophistiquée, et le développement multi-utilisateurs concurrents. VC supporte les opérations d'édition élémentaires sous CVS, mais pour certaines tâches moins ordinaires, vous aurez toujours besoin d'invoquer CVS depuis la ligne de commande. Notez aussi qu'avant d'utiliser CVS, vous devrez mettre en place un dépositaire, ce qui est un sujet trop complexe à traiter ici.
SCCS est un système de contrôle de version propriétaire mais très utilisé. En termes d'aptitudes, il est le plus faible que VC supporte. VC compense certaines caractéristiques manquantes de SCCS (les instantanés, par exemple) en les implémentant lui-même, mais certaines autres caractéristiques de VC, comme les branches multiples, ne sont pas disponibles avec SCCS. Vous devriez utiliser SCCS seulement si pour quelque raison vous ne pouvez pas utiliser RCS.
Lorsqu'un fichier est sous contrôle de version, nous disons aussi qu'il est déclaré dans le système de contrôle de version. Chaque fichier déclaré a un fichier maître correspondant qui représente l'état actuel du fichier plus l'historique de ses changements, de sorte que vous pouvez reconstruire à partir de celui-ci soit la version courante, soit toute version précédente. Habituellement, le fichier maître enregistre aussi une entrée journal pour chaque version, décrivant ce qui a été changé dans cette version.
Le fichier qui est maintenu sous contrôle de version est parfois appelé le fichier de travail correspondant à son fichier maître.
Pour examiner un fichier, vous le retirez. Ceci extrait une version du fichier source (d'ordinaire la plus récente) du fichier maître. Si vous désirez éditer le fichier, vous devez le retirer verrouillé. Seul un utilisateur à la fois peut faire ceci pour un fichier source donné. (cette sorte de verrouillage est sans aucun rapport avec le verrouillage qu'utilise Emacs pour détecter des éditions simultanées d'un fichier.)
Lorsque vous avez fini votre édition, vous devez faire enregistrer la nouvelle version. Ceci enregistre la nouvelle version dans le fichier maître, et déverrouille le fichier source pour qu'un autre utilisateur puisse le verrouiller et ainsi le modifier.
Retirer et faire enregistrer sont les opérations élémentaires du contrôle de version. Vous pouvez les faire toutes deux avec une commande Emacs unique : C-x C-q (vc-toggle-read-only).
Il existe cependant des variantes de ce schéma élémentaire. CVS, par exemple, n'utilise pas le verrouillage, et vous pouvez alors éditer normalement les fichiers, sans avoir à les retirer d'abord. Section 16.7.2.6. Avec RCS, vous pouvez optionnellement sélectionner un verrouillage non strict pour un fichier source particulier ; vous pouvez alors éditer le fichier sous Emacs sans le verrouiller explicitement.
Un instantané est une collection cohérente de versions des divers fichiers composant un programme. Section 16.7.9.
Voici les commandes pour éditer un fichier maintenu par contrôle de version :
Retire ou fait enregistrer le fichier visité.
Retourne le tampon et le fichier à la dernière version enregistrée.
Retire le dernier changement entré dans le maître pour le fichier visité. Ceci annule votre dernier enregistrement.
Déclare le fichier visité au contrôle de version.
(C-x v est la touche préfixe pour les commandes de contrôle de version ; toutes ces commandes à l'exception de C-x C-q commencent avec C-x v.)
Lorsque vous désirez modifier un fichier maintenu par contrôle de version, tapez C-x C-q (vc-toggle-read-only). Ceci retire le fichier, et indique à RCS ou SCCS de verrouiller le fichier. Ceci rend le fichier accessible en écriture pour vous (et non pour les autres).
Si vous spécifiez un argument préfixe (C-u C-x C-q) pour retirer un fichier, Emacs vous demande un numéro de version, et retire cette version déverouillée. Ceci vous permet de vous rendre à d'anciennes versions, ou à des branches existantes de ce fichier (Section 16.7.6). Vous pouvez alors commencer à éditer la version sélectionnée en tapant C-x C-q de nouveau. (Si vous éditez une ancienne version d'un fichier de cette manière, le fait de le faire enregistrer de nouveau crée une nouvelle branche.)
Sous CVS, il n'est normalement pas nécessaire de retirer explicitement les fichiers. CVS n'a pas de verrouillage ; plusieurs utilisateurs peuvent éditer leurs copies d'un fichier lorsqu'ils le veulent. (Si deux utilisateurs font des changements conflictuels, ils doivent réconcilier leurs changements lorsqu'ils les enregistrent.) On dit alors qu'un retrait implicite a lieu au premier changement d'un fichier.
CVS a un mode alternatif dans lequel le retrait explicite est obligatoire. Et RCS a un moe alternatif appelé verrouillage non strict dans lequel le retrait explicite n'est pas obligatoire. La sélection de ces modes est faite en dehors de VC, mais une fois que vous les avez sélectionnés, VC y obéit. Avec RCS, vous pouvez sélectionner le verrouillage non strict pour un fichier particulier avec la commande rcs -U. Section 16.7.2.6, pour une explication sur la manière de faire cela avec CVS.
Lorsque vous avez fini d'éditer le fichier, tapez C-x C-q de nouveau. Utilisé sur un fichier retiré, cette commande enregistre le fichier. Mais l'enregistrement n'a pas lieu immédiatement ; vous devez d'abord saisir l'entrée journal--une description des changements dans la nouvelle version. C-x C-q ouvre un tampon pour que vous l'y entriez. Lorsque vous avez fini de saisir l'entrée journal, tapez C-c C-c pour terminer ; c'est à ce moment que l'enregistrement a réellement lieu. Section 16.7.3.
Avec RCS et SCCS, un fichier retiré est aussi verrouillé, ce qui veut dire qu'il est modifiable par vous, et par personne d'autre. Aussi longtemps que vous détenez le verrou sur le fichier, personne d'autre ne peut le modifier, et personne ne peut faire enregistrer de changements à cette version. Faire enregistrer vos changements déverrouille le fichier, et ainsi un autre utilisateur peut le verrouiller et le modifier.
CVS, au contraire, n'a pas de concept de verrouillage. Les fichiers de travail sont toujours modifiables, permettant des développements concurrents, avec des conflits possibles résolus au moment de l'enregistrement. Section 16.7.2.6.
Pour spécifier le numéro de version de la nouvelle version, tapez C-u C-x C-q pour faire enregistrer un fichier. Emacs vous demande alors dans le mini-tampon le nouveau numéro de version. Ceci peut être utilisé pour créer une nouvelle branche du fichier (Section 16.7.6), ou pour incrémenter le numéro majeur de version du fichier.
Il n'est pas impossible de verrouiller un fichier que quelqu'un d'autre a déjà verrouillé. Si vous essayez de retirer un fichier qui est verrouillé, C-x C-q vous demande si vous désirez "dérober le verrou". Si vous répondez oui, le fichier devient verrouillé par vous, mais un message est envoyé à la personne qui avait précédemment verrouillé le fichier, pour l'informer du fait. La ligne de mode indique qu'un fichier est verrouillé par quelqu'un d'autre en inscrivant le nom de login de cette personne, avant le numéro de version.
déclare le fichier visité au contrôle de version.
Vous pouvez placer n'importe quel fichier sous contrôle de version en le visitant simplement, puis en tapant C-x v i (vc-register). Après C-x v i, le fichier est déverrouillé et en lecture seule. Tapez C-x C-q si vous désirez commencer à l'éditer.
Lorsque vous déclarez le fichier, Emacs doit choisir quel système de contôle de version utiliser pour ce fichier. Vous pouvez spécifier explicitement votre choix en mettant vc-default-back-end à RCS, CVS ou SCCS. Autrement, s'il existe un sous-répertoire appelé RCS, SCCS, ou CVS, Emacs utilise le système de contrôle de version correspondant. En l'absence de toute spécification, le choix par défaut est RCS si RCS est installé, ou autrement SCCS.
Après avoir déclaré un fichier avec CVS, vous devez donner sa version initiale en tapant C-x C-q. Section 16.7.2.6.
Le numéro de version initial pour un fichier nouvellement déclaré est 1.1, par défaut. Pour spécifier un numéro différent, donnez à C-x v i un argument numérique ; il lit alors le numéro de vesion initial en utilisant le mini-tampon.
Si vc-initial-comment est non nil, C-x v i lit un commentaire initial (un peu comme une entrée journal) décrivant l'usage du fichier source.
Fait revenir le tampon et le fichier à la dernière version enregistrée.
Retire le dernier changement entré dans le maître pour le fichier visité. Ceci annule votre dernier enregistrement.
Si vous voulez annuler vos changements courants et revenir à la dernière version enregistrée, utilisez C-x v u (vc-revert-buffer). Ceci annule votre dernier retrait, laissant le fichier déverrouillé. Si vous désirez faire de nouveaux changements, vous devrez d'abord retirer le fichier de nouveau. C-x v u nécessite une confirmation de votre part, à moins que vous n'ayez pas fait de changements par rapport à la dernière version enregistrée.
C-x v u est aussi la commande à utiliser pour déverrouiller un fichier que vous avez verrouillé puis décidez de ne pas changer.
Vous pouvez annuler un changement après l'avoir enregistré, avec C-x v c (vc-cancel-version). Cette commande efface toute sauvegarde de la version la plus récemment enregistrée. C-x v c offre aussi la possibilité de faire revenir votre fichier de travail et tampon à la version précédente (celle précédant la version effacée). Si vous répondez no, alors VC garde vos changements dans le tampon et verrouille le fichier.
L'option de non retour est utile lorsque vous avez fait enregistrer un changement puis découvrez une erreur triviale dans ces changements ; vous pouvez annuler l'enregistrement erroné, corriger l'erreur, et faire enregistrer le fichier de nouveau.
Lorsque C-x v c ne fait pas revenir le tampon, les entêtes de contrôle de version du tampon ne sont plus développées (sont enveloppées) (Section 16.7.10). La cause est que le tampon ne correspond plus à aucune version existante. Si vous faites enregistrer de nouveau le tampon, le processus d'enregistrement développera correctement les entêtes pour le nouveau numéro de version.
Cependant, il est impossible d'envelopper l'entête RCS $Log: version-control.html,v $ >Revision 1.1 2002/11/19 13:45:23 feloy >*** empty log message *** > automatiquement. Si vous utilisez cette caractéristique des entêtes, vous devez l'envelopper à la main-en effaçant l'entrée pour la version que vous venez d'effacer.
Soyez attentif lorsque vous invoquez C-x v c, car il est facile de perdre de cette manière beaucoup de travail. Pour vous aider à être attentif, cette commande vous demande toujours de confirmer par yes. Notez aussi que cette commande n'est pas disponible sous CVS, car annuler des versions est très dangereux et déconseillé avec CVS.
Lorsque vous visitez un fichier qui est sous contrôle de version, la ligne de mode indique le status courant du fichier : le nom du système de contrôle de version utilisé pour ce fichier, l'état de verrouillage, et la version.
L'état du verrouillage est affiché avec un caractère unique, qui peut être soit - soit :. - indique que le fichier n'est pas verrouillé ou non modifié par vous. Une fois que vous verrouillez le fichier, l'indicateur d'état se change en :. Si le fichier est verrouillé par une autre personne, le nom de l'utilisateur apparaît après le numéro de version.
Par exemple, RCS-1.3 veut dire que vous examinez la version 1.3 par RCS, qui n'est pas verrouillée. RCS:1.3 veut dire que vous avez verrouillé le fichier, et avez pu commencé à le modifier. RCS:jim:1.3 indique que le fichier est verrouillé par jim.
Avec CVS, les fichiers ne sont jamais verrouillés. Deux utilisateurs peuvent retirer le même fichier en même temps ; chaque utilisateur obtient une copie séparée et peut l'éditer. Les fichiers de travail sont toujours modifiables ; une fois retiré, vous n'avez pas à taper une commande de VC pour commencer à éditer le fichier. Vous pouvez l'éditer à n'importe quel moment.
En utilisant RCS et SCCS, vous utilisez normalement C-x C-q deux fois pour chaque changement ; une fois avant le changement, pour retirer le fichier, et une fois après, pour le faire enregistrer. Avec CVS, c'est différent : vous utilisez normalement C-x C-q une seule fois pour chaque changement, pour soumettre le changement une fois fait. Le fichier de travail reste modifiable, et vous pouvez de nouveau commencer à l'éditer sans utiliser de commande spéciale.
Une manière de comprendre ceci est que VC fait un retrait implicite lorsque vous enregistrez le fichier modifié pour la première fois. VC l'indique dans la ligne de mode : l'indicateur de status change de - en : aussitôt que vous enregistrez une version modifiée, vous indiquant que vous n'êtes plus synchronisé avec le dépositaire (Section 16.7.2.5). Le fichier reste "retiré" tant que vous ne le faites pas enregistrer de nouveau, même si vous détruisez le tampon et visitez de nouveau le fichier.
Si, plutôt, vous voudriez utiliser le retrait explicite avec CVS, mettez la variable d'environnement CVSREAD à une valeur quelconque. (La valeur que vous lui donnez n'importe pas.) CVS rend alors vos fichiers de travail en lecture seule par défaut, et VC attend que vous les retiriez explicitement avec C-x C-q. Lorsque vous définissez CVSREAD pour la première fois, faites attention de retirer tous vos modules de nouveau, pour que les protections des fichiers soient correctement définies.
VC ne fournit pas de moyen de retirer une copie de travail d'un fichier existant du dépositaire. Vous devez utiliser les commandes shell de CVS pour faire cela. Une fois que vous avez un fichier de travail, vous pouvez commencer à utiliser VC pour ce fichier.
La terminologie de CVS parle de soumettre un changement plutôt que de le faire enregistrer. Mais en termes pratiques ils marchent de la même manière : Emacs vous demande de taper une entrée journal, et vous la terminez avec C-c C-c.
Lorsque vous tentez de soumettre les changements d'un fichier, mais que quelqu'un d'autre a soumis d'autres changements pendant ce temps, un conflit est créé. VC détecte cette situation et propose de mêler vos changements et ceux de l'autre utilisateur, créant une nouvelle version locale du fichier, que vous pouvez alors soumettre au dépositaire. Ceci marche bien si les changements sont faits sur différentes parties du fichier, bien qu'il soit prudent de vérifier l'uniformité sémantique du fichier résultant.
Cependant, si vous et l'autre utilisateur avez modifié les mêmes parties du fichier, le conflit ne peut être résolu automatiquement. Dans ce cas, CVS insére les deux variantes des régions en conflit dans le fichier de travail, et place des marques de conflit autour d'elles. Elles indiquent à quoi ressemble la région dans les versions respectives de chaque utilisateur. Vous devez résoudre le conflit manuellement, par exemple en choisissant une des deux variantes et en supprimant l'autre (et les marques de conflit). Vous pouvez alors soumettre le fichier résultant au dépositaire. L'exemple suivant montre l'apparence d'une région en conflit ; le fichier est appelé nom et la version courante du dépositaire avec les changements de l'utilisateur B est 1.11.
<<<<<<< nom
User A's version
=======
User B's version
>>>>>>> 1.11
|
Vous pouvez empêcher l'utilisation de VC pour les fichiers gérés par CVS en mettant la variable vc-handle-cvs à nil. Si vous faites cela, Emacs traite ces fichiers comme s'ils n'étaient pas gérés, et les commandes VC ne sont pas disponibles pour ceux-là. Vous devez faire toutes les opérations CVS manuellement.
Lorsque vous éditez un commentaire initial ou une entrée journal à inclure dans un fichier maître, terminez l'entrée en tapant C-c C-c.
Termine l'édition de commentaire normalement (vc-finish-logentry). Ceci termine l'enregistrement.
Pour annuler l'enregistrement, ne tapez pas C-c C-c dans ce tampon. Vous pouvez aller dans d'autres tampons et faire d'autres éditions. Aussi longtemps que vous n'essayez pas de faire enregistrer un autre fichier, l'entrée que vous étiez en train d'éditer reste dans son tampon, et vous pouvez revenir à ce tampon à tout moment pour terminer l'enregistrement.
Si vous modifiez plusieurs fichiers sources pour la même raison, il est souvent pratique de spécifier la même entrée journal pour tous ces fichiers. Pour faire cela, utilisez l'historique des entrées journal précédentes. Les commandes M-n, M-p, M-s et M-r pour faire cela fonctionnent exactement comme les commandes d'historique du mini-tampon (excepté que ces versions sont utilisées en dehors du mini-tampon).
Chaque fois que vous faites enregistrer un fichier, le tampon des entrées journal est placé en mode Journal VC, ce qui nécessite d'exécuter deux commandes crochet : text-mode-hook et vc-log-mode-hook. Section 32.2.3.
Si vous utilisez RCS pour un programme et maintenez aussi un fichier Journal des changements pour lui (Section 24.14), vous pouvez générer des entrées du journal des changements automatiquement à partir des entrées journal du contrôle de version :
Visite le fichier journal des changements du répertoire courant et, pour les fichiers déclarés de ce répertoire, crée de nouvelles entrées pour les versions enregistrées depuis l'entrée la plus récente dans le fichier journal des changements. (vc-update-change-log).
Cette commande fonctionne uniquement avec RCS et CVS, et non avec SCCS.
Comme précédemment, mais trouve seulement les entrées pour le fichier du tampon courant.
Comme précédemment, mais trouve les entrées pour tous les fichiers couramment visités étant maintenus par contrôle de version. Ceci fonctionne uniquement avec RCS, et place toutes les entrées dans le journal pour le répertoire par défaut, qui peut ne pas être approprié.
Par exemple, supposez que la première ligne de ChangeLog soit daté du 10 Avril 1992, et que le seul enregistrement depuis ait été fait par Nathaniel Bowditch à rcs2log le 8 Mai 1992 avec comme texte de journal Ignorez les messages du journal commençant par `#'.. C-x v a visite alors ChangeLog et insére du texte tel que :
Fri May 8 21:45:00 1992 Nathaniel Bowditch <nat@apn.org>
* rcs2log: Ignorez les messages du journal commençant par `#'.
|
Vous pouvez alors éditer la nouvelle entrée du journal des changements si vous le désirez.
Normalement, l'entrée journal pour le fichier foo est affiché * foo: text de l'entrée journal. Le : après foo est omis si le texte de l'entrée journal commence avec (functionname):. Par exemple, si l'entrée journal pour vc.el est (vc-do-command): Check call-process status., alors le texte dans ChangeLog sera :
Wed May 6 10:53:00 1992 Nathaniel Bowditch <nat@apn.org>
* vc.el (vc-do-command): Check call-process status.
|
Lorsque C-x v a ajoute plusieurs entrées au journal des changements en même temps, il regroupe les entrées journal si toutes sont enregistrées par le même auteur à la même date. Si les entrées journal de plusieurs fichiers ont toutes le même texte, il les regroupe dans une seule entrée. Par exemple, supposez que le dernier enregistrement ait les entrées journal suivantes :
• Pour vc.texinfo: Fixe typos expansion. • Pour vc.el: N'appelle pas expand-file-name. • Pour vc-hooks.el: N'appelle pas expand-file-name.
Elles apparaissent ainsi dans ChangeLog:
Wed Apr 1 08:57:59 1992 Nathaniel Bowditch <nat@apn.org>
* vc.texinfo: Fixe typos expansion.
* vc.el, vc-hooks.el: N'appelle pas expand-file-name.
|
Normalement, C-x v a sépare les entrées journal par une ligne vierge, mais vous pouvez marquer plusieurs entrées journal pour qu'elles soient réunies (sans ligne vierge entre elles) en commençant le texte de chaque entrée journal avec une étiquette de la forme {nom} . L'étiquette elle-même n'est pas copiée dans ChangeLog. Par exemple, supposez que les entrées journal soient :
• Pour vc.texinfo: {expand} Fixe typos expansion. • Pour vc.el: {expand} N'appelle pas expand-file-name. • Pour vc-hooks.el: {expand} N'appelle pas expand-file-name.
Le texte dans ChangeLog apparaît alors ainsi :
Wed Apr 1 08:57:59 1992 Nathaniel Bowditch <nat@apn.org>
* vc.texinfo: Fixe typos expansion.
* vc.el, vc-hooks.el: N'appelle pas expand-file-name.
|
Une entrée journal dont le texte commence par # n'est pas copié dans ChangeLog. Par exemple, si vous corrigez simplement quelques fautes d'orthographe dans les commentaires, vous pouvez journaliser le changement avec # pour éviter de le mettre dans ChangeLog.
Sélectionne la version version comme version du fichier de travail courant.
Examine la version version du fichier visité, dans son propre tampon.
Compare le contenu du tampon courant avec la dernière version enregistrée du fichier.
Compare les deux version spécifiées de fichier.
Affiche le résultat de la commande d'annotation de CVS en utilisant des couleurs.
Il existe deux moyens de travailler avec une ancienne version d'un fichier. Vous pouvez prendre l'ancienne version comme fichier de travail, par exemple si vous désirez reproduire un stage précédent du développement, ou si vous désirez créer une branche pour l'ancienne version. (Section 16.7.6). Pour faire cela, visitez le fichier et tapez C-u C-x C-q version RET. (Ceci marche seulement avec RCS.)
Si vous désirez seulement examiner une ancienne version, sans changer de fichier de travail, visitez le fichier puis tapez C-x v ~ version RET (vc-version-other-window). Ceci place le texte de la version version dans un fichier appelé nom_fichier.~version~, et le visite dans son propre tampon, dans une fenêtre séparée.
Pour comparer deux versions d'un fichier, utilisez la commande C-x v = (vc-diff). C-x v = seul compare le contenu du tampon courant (en l'enregistrant dans un fichier si nécessaire) avec la dernière version enregistrée du fichier. C-u C-x v =, avec un argument numérique, lit un nom de fichier et deux numéros de version, puis compare ces versions du fichier spécifié.
Si vous donnez un nom de répertoire plutôt q'un nom de fichier de travail, cette commande compare les deux version spécifiées de tous les fichiers déclarés dans ce répertoire et ses sous-répertoires. Vous pouvez aussi spécifier un nom d'instantané (Section 16.7.9) à la place de l'un ou des deux numéros de version.
Vous pouvez spécifier une version enregistrée par son nombre ; une entrée vierge spécifie le contenu courant du fichier de travail (qui peut être différent de toutes les versions enregistrées).
Cette commande fonctionne en exécutant l'utilitaire diff, obtenant les options de la variable diff-switches. Elle affiche la sortie dans un tampon spécial dans une autre fenêtre. À l'inverse de la commande M-x diff, C-x v = n'essaie pas de localiser les changements entre l'ancienne et la nouvelle version. Ceci car normalement, les deux versions n'existent pas en tant que fichier lorsque vous les comparez ; elles existent seulement dans les enregistrements du fichier maître. Section 16.9, pour plus d'informations sur M-x diff.
Pour des fichiers contrôlés par CVS, vous pouvez afficher le résultat de la commande d'annotation, en utilisant des couleurs pour améliorer l'apparence visuelle. Utilisez la commande M-x vc-annotate pour faire cela. Rouge veut dire nouveau, bleu veut dire ancien, et des couleurs intermédiaires indique des âges intermédiaires. Un argument préfixe n spécifie un facteur d'envergure pour l'échelle de temps ; il fait couvrir chaque couleur une période n fois plus longue.
Une utilisation du contrôle de version est de maintenir plusieurs versions "courantes" d'un fichier. Par exemple, vous pouvez avoir plusieurs versions d'un programme dans lesquelles vous ajoutez graduellement diverses nouvelles caractéristiques non terminées. Chacune de ces lignes de développement indépendantes sont appelées des branches. Notez, cependant, que les branches sont seulement supportées par RCS.
La ligne de développement principale d'un fichier est habituellement appelée le tronc. Les versions du tronc sont en général numérotées 1.1, 1.2, 1.3, etc. À chacune de ces versions, vous pouvez démarrer une branche indépendante. Une branche démarrant à la version 1.2 aura un numéro de version 1.2.1.1. Les versions consécutives de cette branche seront numérotées 1.2.1.2, 1.2.1.3, 1.2.1.4, et ainsi de suite. Si une seconde branche démarre à la version 1.2, elle sera constituée des versions 1.2.2.1, 1.2.2.2, 1.2.2.3, et ainsi de suite.
Si vous omettez le composant final d'un numéro de version, ceci est appelé un numéro de branche. Il se réfère à la version existante la plus haute dans cette branche. Les branches dans l'exemple précédent ont des numéros de branche 1.2.1 et 1.2.2.
Une version qui est la dernière dans sa branche est appelée une version de tête.
Pour passer d'une branche à une aute, tapez C-u C-x C-q et spécifiez le numéro de version que vous désirez sélectionner. Cette version est alors retirée déverrouillée (protégée en écriture), pour que vous puissiez l'examiner avant de la retirer vraiment. Passer d'une branche à une autre de cette manière est autorisé seulement si le fichier n'est pas verrouillé.
Vous pouvez omettre le numéro mineur de la version, donnant ainsi seulement le numéro de branche ; ceci vous donne la version la plus haute de la branche indiquée. Si vous tapez seulement RET, Emacs va à la version la plus haute dans le tronc.
Après être passé à une autre branche (incluant la branche principale), vous y restez pour les commandes VC suivantes, jusqu'à ce que vous passiez explicitement à une autre branche.
Pour créer une nouvelle branche depuis une version de tête (la dernière dans sa branche), sélectionnez d'abord cette version si nécessaire, verrouillez-la avec C-x C-q, et faites les changements que vous désirez. Ensuite, lorsque vous faites enregistrer vos changements, utilisez C-u C-x C-q. Ceci vous laisse spécifier le numéro de version pour la nouvelle version. Vous devez spécifier un numéro de branche adapté pour une branche démarrant à la version en cours. Par exemple, si la version courante est 2.5, le numéro de branche doit être 2.5.1, 2.5.2, et ainsi de suite, selon le nombre de branches existant déjà à cet endroit.
Pour créer une nouvelle branche à partir d'une ancienne version (une qui n'est plus la tête de la branche), sélectionnez d'abord cette version, puis verrouillez-la avec C-x C-q. Il vous sera demandé de confirmer, lorsque vous verrouillez l'ancienne version, que vous désirez réellement créer une nouvelle branche-si vous répondez non, il vous sera offert la chance de verrouiller plutôt la dernière version.
Faites alors vos changements et tapez C-x C-q de nouveau pour faire enregistrer une nouvelle version. Ceci crée automatiquement une nouvelle branche démarrant à la verrsion sélectionnée. Vous n'avez pas besoin de demander à créer une nouvelle branche, car c'est le seul moyen d'ajouter une nouvelle version à un point qui n'est pas la tête d'une branche.
Une fois que la branche est créée, vous y "restez". Cela veut dire que les retraits et enregistrements suivants créent de nouvelles versions dans cette branche. Pour quitter la branche, vous devez explicitement sélectionner une nouvelle version avec C-u C-x C-q pour la retirer.
Il est parfois utile pour plusieurs utilisateurs de travailler simultanément sur différentes branches d'un fichier. Ceci est possible si vous créez plusieurs répertoires de sources. Chaque répertoire de sources doit avoir un lien appelé RCS pointant vers un répertoire commun de fichiers maîtres RCS. Alors chacun des répertoires de sources peut avoir son propre choix de versions retirées, mais tous partagent les mêmes enregistrements RCS.
Cette technique fonctionne correctement et automatiquement, à condition que les fichiers sources contiennent des entêtes de version RCS (Section 16.7.10). Les entêtes permettent à Emacs de savoir exactement, à tout moment, quel numéro de version est présent dans le fichier de travail.
Si les fichiers n'ont pas d'entête de version, vous devez à la place indiquer explicitement à Emacs et à chaque session dans quelle branche vous travaillez. Pour faire cela, trouvez d'abord le fichier, puis tapez C-u C-x C-q et spécifiez le numéro de branche correct. Ceci assure qu'Emacs connaît la branche qu'il utilise durant une session d'édition particulière.
Pour voir le status détaillé du contrôle de vesion et l'historique d'un fichier, tapez C-x v l (vc-print-log). Cette commande affiche l'historique des changements du fichier courant, le texte des entrées journal inclus. La sortie apparraît dans une fenêtre séparée.
Lorsque vous travaillez sur un gros programme, il est souvent nécessaire de trouver tous les fichiers couramment verrouillés, ou tous les fichiers maintenus par contrôle de version. Vous pouvez utiliser C-x v d (vc-directory) pour voir tous les fichiers verrouillés dans ou sous un certain répertoire. Ceci inclut tous les fichiers verrouillés par n'importe quel utilisateur. C-u C-x v d liste tous les fichiers dans ou sous le répertoire spécifié qui sont maintenus par contrôle de version.
La liste des fichiers est affichée dans un tampon qui utilise un mode Dired étendu. Les noms des utilisateurs possédant un verrou sur divers fichiers sont affichés (entre parenthèses) à la place du propriétaire et du groupe. (Avec CVS, un status plus détaillé est affiché pour chaque fichier.) Toutes les commandes Dired ordinaires fonctionnent dans ce tampon. La plupart des commandes interactives de VC fonctionnent aussi, et s'appliquent au nom de fichier de la ligne courante.
La commande C-x v v (vc-next-action), lorsqu'elle est utilisée dans le tampon Dired étendu, opère sur tous les fichiers marqués (ou le fichier de la ligne courante). Si elle opère sur plus d'un fichier, elle gère chacun des fichiers selon son état courant ; ainsi, elle peut retirer un fichier et faire enregistrer un autre (car il est déjà retiré). Si elle doit faire enregistrer plusieurs fichiers, elle lit une seule entrée journal, et utilise ce texte pour tous les fichiers à faire enregistrer. Ceci peut être pratique pour déclarer ou faire enregistrer plusieurs fichiers en même temps, au cours d'un même changement.
de VC
Lorsque vous renommez un fichier déclaré, vous devez aussi renommer son fichier maître pour obtenir un résultat correct. Utilisez vc-rename-file pour renommer le fichier source comme vous le désirez, et renommer le fichier maître correctement. Elle met aussi à jour tous les instantanés (Section 16.7.9) mentionnant ce fichier, pour qu'ils utilisent le nouveau nom ; en dépit de ça, l'instantané ainsi modifié peut ne pas fonctionner totalement (Section 16.7.9.2).
Vous ne pouvez pas utiliser vc-rename-file avec un fichier étant verrouillé par quelqu'un d'autre.
Un instantané est un jeu nommé de versions de fichiers (une pour chaque fichier déclaré) que vous pouvez traiter comme une unité. Un type important d'instantané est une release, une version (théoriquement) stable du système qui est prête à être distribuée à des utilisateurs.
Il existe deux commandes élémentaires pour les instantanés ; une crée un instantané portant un nom donné, l'autre retire un instantané d'après son nom.
Définit les dernières versions enregistrées de tous les fichiers déclarés dans ou sous le répertoire courant comme instantané appelé nom (vc-create-snapshot).
Retire tous les fichiers déclarés dans ou sous le répertoire courant en utilisant les versions correspondant à l'instantané nom (vc-retrieve-snapshot).
Cette commande retourne une erreur si des fichiers dans ou sous le répertoire courant sont verrouillés, sans rien changer ; ceci permet d'éviter de perdre du travail en cours.
Un instantané utilise une quantité très petite de ressources--juste assez pour sauvegarder une liste de fichiers et leurs versions correspondant à l'instantané. Ainsi, n'hésitez pas à créer des instantanés lorsqu'ils peuvent être utiles.
Vous pouvez donner un nom d'instantané comme argument à C-x v = ou C-x v ~ (Section 16.7.5). Ainsi, vous pouvez utiliser ce moyen pour comparer un instantané avec les fichiers courants, ou deux instantanés entre eux, ou encore un instantané et une certaine version.
Les instantanés de VC sont modelés dans le support de configurations nommées de RCS. Ils utilisent les possibilités natives de RCS pour cela, ainsi sous VC les instantanés utilisant RCS sont visibles même si vous n'utlisez pas VC pour les créer.
Pour SCCS, VC implémente lui-même les instantanés. Les fichiers qu'il utilise contiennent des triplets nom/fichier/numéro de version. Ces instantanés sont visibles seulement sous VC.
Un instantané est un jeu de versions enregistrées. Prenez donc garde que tous les fichiers sont enregistrés et déverrouillés lorsque vous créez un instantané.
Le renommage et la suppression de fichiers peut créer quelques difficultés avec les instantanés. Ceci n'est pas un problème spécifique à VC, mais aux systèmes de contrôle de version en général qui n'a pas été trop bien résolu à cette heure.
Si vous renommez un fichier déclaré, vous devez renommer son fichier maître en même temps (la commande vc-rename-file le fait automatiquement). Si vous utilisez SCCS, vous devez aussi mettre à jour les enregistrements de l'instantané, pour mentionner le fichier parr son nouveau nom (vc-rename-file le fait, aussi). Un ancien instantané qui se réfère à un fichier maître qui n'existe plus sous le nom enregistré est invalide ; VC ne peut plus le retrouver. Il serait en dehors de la portée de manuel d'expliquer comment mettre à jour manuellement les instantanés pour RCS et SCCS.
L'utilisation de vc-rename-file permet de garder l'instantané valide pour les retraits, mais il ne résout pas tous les problèmes. Par exemple, certains fichiers d'un programme se réfèrent probablement à d'autres par leur nom. Le makefile mentionne probablement le fichier que vous avez renommé. Si vous retirez un ancien instantané, le fichier renommé est retiré sous son nouveau nom, qui n'est pas le nom que le makefile attend. Le programme ne fonctionnera donc pas comme il le faut.
Il est parfois utile de placer des chaînes d'identification de version directement dans les fichiers de travail. Certaines chaînes spéciales appelées entêtes de version sont remplacées dans chaque version successive par le numéro de version.
Si vous utilisez RCS, et que des entêtes de version sont présentes dans vos fichiers de travail, Emacs peut utiliser celles-ci pour déterminer la version courante et l'état des verrous des fichiers. Ceci est plus sûr que de se référer aux fichiers maîtres, ce qui est fait lorsqu'il n'y a pas d'entêtes de version. Notez que dans un environnement multi-branches, les entêtes de version sont nécessaires pour que VC fonctionne correctement (Section 16.7.6.3).
La recherche des entêtes de version est contrôlée par la variable vc-consult-headers. Si elle est non nil, Emacs recherche les entêtes pour déterminer le numéro de la version que vous éditez. Mettre cette variable à nil stoppe cette caractéristique.
Vous pouvez utiliser la commande C-x v h (vc-insert-headers) pour insérer une chaîne d'entête convenable.
Insère des entêtes dans un fichier à utiliser avec votre système de contrôle de version.
La chaîne d'entête par défaut est $Id: version-control.html,v 1.1 2002/11/19 13:45:23 feloy Exp $ pour RCS et %W% pour SCCS. Vous pouvez spécifier d'autres entêtes à insérer en définissant la variable vc-header-alist. Sa valeur est une liste d'éléments de la forme (programme . chaîne) où programme est RCS ou SCCS et chaîne est la chaîne à utiliser.
Plutôt qu'une seule chaîne, vous pouvez spécifier une liste de chaînes ; ainsi chaque chaîne de la liste est insérée comme entête à part entière sur sa propre ligne.
Il est parfois nécessaire d'utiliser des barres obliques inverses "superflues" pour écrire les chaînes que vous placez dans cette variable. Ceci pour empêcher la chaîne d'être interprétée comme une entête elle-même si le fichier Emacs Lisp la contenant est maintenue par contrôle de version.
Chaque entête est insérée entourée de tabs, et entre des délimiteurs de commentaire, sur une nouvelle ligne au début du tampon. Normalement, les chaînes de début et de fin de commentaire du mode courant sont utilisées, mais pour certains modes, il existe des délimiteurs de commentaires dédiés à cet usage ; la variable vc-comment-alist spécifie ces délimiteurs. Chaque élément de la liste a la forme (mode début fin).
La variable vc-static-header-alist spécifie des chaînes supplémentaires à rajouter basées sur le nom du tampon. Sa valeur doit être une liste d'éléments de la forme (regexp . format). Lorsque regexp correspond au nom du tampon, format est inséré dans l'entête. Une ligne d'entête est insérée pour chaque élément correspondant au nom du tampon, et pour chaque chaîne spécifiée par vc-header-alist. La ligne d'entête est créée en passant la chaîne de vc-header-alist dans le format pris dans l'élément. La valeur par défaut pour vc-static-header-alist est :
(("\\.c$" .
"\n#ifndef lint\nstatic char vcid[] = \"\%s\";\n\
#endif /* lint */\n"))
|
Ce qui spécifie l'insertion d'un texte de la forme :
#ifndef lint
static char vcid[] = "chaîne";
#endif /* lint */
|
Notez que le texte précédent commence par une ligne vierge.
Si vous utilisez plus d'une entête de version dans un fichier, placez-les à côté dans le fichier. Le mécanisme de revert-buffer qui préserve les marques peut ne pas tenir compte des marqueurs placés entre deux entêtes de version.
Il y a plusieurs moyens de personnaliser VC. Les variables qui contrôlent son comportement tombent dans trois catégories, décrites dans les sections suivantes.
Emacs ne crée normalement pas de fichier archive pour les fichiers source qui sont maintenus par contrôle de version. Si vous désirez créer des fichiers archives même pour ces fichiers, mettez la variable vc-make-backup-files à une valeur nonnil.
Normalement, le fichier archive existe toujours, qu'il soit verrouilléé ou non. Si vous mettez vc-keep-workfiles à nil, alors faire enregistrer une nouvelle version avec C-x C-q efface le fichier de travail ; mais tout essai d'ouvrir le fichier avec Emacs crée de nouveau ce fichier. (Avec CVS, les fichiers de travail sont toujours conservés.)
L'édition d'un fichier sous contrôle de version à travers un lien symbolique peut être dangereux. Elle outrepasse le système de contrôle de version--il est possible d'éditer le fichier sans avoir à le retirer, et de ne pas pouvoir en faire enregistrer les changements. De plus, vos changements peuvent écraser ceux d'un autre utilisateur. Pour vous protéger de cela, VC vérifie tous les liens symboliques que vous visitez, pour voir s'il pointe vers un fichier sous contrôle de version.
La variable vc-follow-symlinks contrôle ce qu'il faut faire lorsqu'un lien symbolique pointe sur un fichier sous contrôle de version. Si elle est nil, VC affiche seulement un message d'avertissement. Si elle est t, VC suit automatiquement le lien, et visite plutôt le fichier réel, en vous avertissant dans la zone de répercussion. Si la valeur est ask (par défaut), VC vous demande à chaque fois s'il faut suivre le lien.
Lorsqu'il déduit l'état verrouillé/déverrouillé d'un fichier, VC recherche d'abord une chaîne d'entête de version RCS dans le fichier (Section 16.7.10). S'il n'y a pas de chaîne entête, ou si vous utilisez SCCS, VC examine normalement les permissions de fichier du fichier de travail ; ceci est rapide. Mais dans certaines situations les permissions de fichier ne peuvent être crédibles. Dans ce cas le fichier maître doit être consulté, ce qui est assez coûteux. De plus le fichier maître peut seulement vous dire si un verrou est posé sur le fichier, mais non si votre fichier de travail contient cette version verrouillée.
Vous pouvez indiquer à VC de ne pas utiliser les entêtes de version pour déterminer l'état de verrouillage en mettant vc-consult-headers à nil. VC utilise alors toujours les permissions de fichier (si elles sont crédibles), ou bien vérifie le fichier maître.
Vous pouvez spécifier le critère de crédibilité des permissions de fichier en définissant la variable vc-mistrust-permissions. Sa valeur peut être t (ne jamais croire les permissions de fichier et examiner le fichier maître), nil (toujours croire les permissions de fichier), ou une fonction avec un argument qui prend la décision. L'argument est le nom de répertoire du sous-répertoire RCS, CVS ou SCCS. Une valeur non nil retournée par la fonction indique de ne pas croire les permissions de fichier. Si vous trouvez que les permissions de fichier des fichiers de travail sont modifiées de façon incorrecte, mettez vc-mistrust-permissions à t. VC vérifie toujours alors le fichier maître pour déterminer le status d'un fichier.
Si vc-suppress-confirm est non nil, alors C-x C-q et C-x v i peuvent sauvegarder le tampon courant sans demander, et C-x v u opère aussi sans demander confirmation. (Cette variable n'affecte pas C-x v c; cette opération est si radicale qu'elle doit toujours demander une confirmation.)
Le mode VC fait le plus gros de son travail en exécutant les commandes shell de RCS, CVS et SCCS. Si vc-command-messages est non nil, VC affiche des messages indiquant quelles commandes shell il exécute, et un message additionnel lorsque la commande finit.
Vous pouvez spécifier des répertoires supplémentaires pour la recherche des programmes de contrôle de version en définissant la variable vc-path. Ces épertoires sont parcourus avant le chemin de recherche usuel. Mais les bons fichiers sont d'habitude trouvés automatiquement.