Comment revenir à une version antérieure de notre code dans Subversion?

Je travaille sur un projet avec un ami et je veux revenir à une ancienne version de notre code et la définir comme étant la version actuelle. Comment fait-on ça?

J’utilise “anksvn” sur vs08.

J’ai la version que je veux sur mon PC, mais la validation échoue; Le message que je reçois est “échec de la validation, fichier ou répertoire obsolète”.

J’ai aussi le client subversion sur mon PC.

Fondamentalement, vous devez “fusionner en arrière” – appliquez un diff entre la version actuelle et la version précédente à la version actuelle (afin que vous vous retrouviez avec une copie de travail ressemblant à l’ancienne version), puis validez à nouveau. Donc par exemple passer de la révision 150 (actuelle) à la révision 140:

svn update svn merge -r 150:140 . svn commit -m "Rolled back to r140" 

Le livre rouge de Subversion contient une bonne partie à ce sujet .

La raison pour laquelle vous ne pouvez rien faire directement avec la bonne copie que vous avez sur votre PC, est que ses dossiers .svn savent qu’il s’agit d’un code du passé, il faut donc une mise à jour. Mais vous ne pouvez réellement engager des changements qu’à la tête de l’histoire de la subversion.

Vous pouvez utiliser

svn update -r

pour vérifier les différentes versions plus anciennes de votre projet, jusqu’à ce que vous trouviez le bon numéro de révision, de votre bonne version. Lorsque vous l’avez trouvé, mettez à jour la dernière révision (head), puis appliquez le svn merge comme suggéré ci-dessus.

Si vous ne le trouvez pas vraiment, et que vous avez besoin de valider la copie sur votre PC, procurez-vous une nouvelle mise à jour de la dernière version et copiez-la par-dessus ( sans les dossiers .svn!). Supprimez tous les fichiers qui n’étaient pas dans la bonne copie des dossiers et de subversion et validez ce que vous avez maintenant.

Utilisez simplement cette ligne

svn update -r yourOldRevesion

Vous pouvez connaître votre révision actuelle en utilisant:

svn info

La méthode standard d’utilisation de la fusion pour annuler l’intégralité de l’enregistrement fonctionne parfaitement, si c’est ce que vous voulez faire. Parfois, cependant, tout ce que vous voulez faire est de restaurer un seul fichier. Il n’y a pas de moyen légitime de le faire, mais il y a un piratage:

  1. Recherchez la version que vous souhaitez utiliser en utilisant svn log.
  2. Utilisez la sous-commande svn’s export:

    svn export http: // url-to-votre-fichier @ 123 / tmp / filename

(Où 123 est le numéro de révision pour une bonne version du fichier.) Ensuite, déplacez ou copiez ce fichier unique pour remplacer l’ancien. Vérifiez le fichier modifié et vous avez terminé.

Un peu plus vieille école

 svn diff -r 150:140 > ../r140.patch patch -p0 < ../r140.patch 

alors l'habituel

 svn diff svn commit 

Je pense que cela convient le mieux:

Faire la fusion en arrière, par exemple, si le code validé contient la révision de la version 5612 à la page 5616, fusionnez-la simplement en arrière. Cela fonctionne à ma fin.

Par exemple:

 svn merge -r 5616:5612 https:/// 

Il contiendrait un code fusionné à la révision précédente, vous pourriez alors le valider.

C’est ce que j’ai fait et travaillé pour moi.

Je souhaite annuler les modifications de plusieurs commits que j’ai effectuées à certains moments et que je souhaite passer au sharepoint validation précédent.

  1. Aller à l’équipe -> Afficher l’historique.
  2. Cliquez avec le bouton droit sur la plage de révisions que vous souhaitez ignorer.
  3. Sélectionnez l’option “Annuler les modifications”.

Cela exécutera une fusion inverse, annulant les modifications dans votre copie de travail.

Revoyez simplement le code et validez.

Cliquez avec le bouton droit de la souris sur la hiérarchie la plus élevée que vous souhaitez rétablir >> Revert ou revenir Revert to Revision

Cliquez avec le bouton droit sur le projet> Remplacer par> Révision ou URL> Sélectionnez la révision spécifique que vous souhaitez rétablir.

Maintenant, validez la version du code de mise à jour local dans le référentiel. Cela ramènera la base de code à la révision spécifique.

La plupart des réponses précédentes utilisaient une fusion inverse, et c’est généralement la bonne réponse. Cependant, il y a une situation (ce qui m’est arrivé) où ce n’est pas le cas.

J’ai accidentellement changé un fichier avec des fins de ligne Unix en fins de ligne DOS lors d’une modification mineure et l’ai validé. Ceci est facilement annulé, soit en changeant les fins de ligne et en validant à nouveau, soit par une fusion inverse, mais cela a pour effet de faire de ma modification comme source de chaque ligne du fichier. (Fait intéressant, TortoiseSVN sous Windows n’est pas affecté par cela; seule la ligne de commande svn blame .)

Si vous voulez conserver l’historique tel que rapporté par svn blame , je pense que vous devez faire ce qui suit:

  • Supprimez le fichier et validez.
  • Dans le référentiel, copiez la bonne copie précédente du fichier dans la tête et validez.
  • Restaurez toutes les modifications que vous souhaitez conserver.

La suppression est un peu effrayante, mais rappelez-vous que vous avez toujours le fichier enregistré dans le référentiel, donc la restaurer n’est pas une grosse affaire. Voici un code pour illustrer les étapes. Supposons que xxx soit le numéro de révision de la dernière bonne copie.

 svn rm svn+ssh://path/to/file svn copy svn+ssh://path/to/file@xxx svn+ssh://path/to -m"Restore good copy" svn update  svn commit -m"Restore edits" 

Notez que pour une copie dans le référentiel, la destination doit être un répertoire, pas un nom de fichier.

Synchroniser avec l’ancienne version et la valider. Cela devrait faire l’affaire.

Voici également une explication des modifications annulées.

La réponse de Jon Skeet est en gros la solution, mais si vous êtes comme moi, vous voudrez peut-être une explication. Le manuel Subversion appelle cela un

Cherry-Pick Merge

A partir des pages de manuel.

  1. Cette forme s’appelle une fusion ‘cherry-pick’: ‘-r N: M’ fait référence à la différence dans l’historique de la twig source entre les révisions N et M.

    Une «plage inversée» peut être utilisée pour annuler les modifications. Par exemple, lorsque la source et la cible font référence à la même twig, une révision précédemment validée peut être «annulée». Dans une plage inversée , N est supérieur à M dans «-r N: M» ou l’option «-c» est utilisée avec un nombre négatif: «-c -M» est équivalent à «-r M:». L’annulation de modifications comme celle-ci est également connue sous le nom de «fusion inversée».


  • Si la source est un fichier, des différences sont appliquées à ce fichier (utile pour inverser les modifications antérieures). Sinon, si la source est un répertoire, la cible par défaut est “.”

    En utilisation normale, la copie de travail doit être à jour, à une seule révision, sans modifications locales et sans sous-arborescence commutée.

Exemple:

 svn merge -r 2983:289 path/to/file 

Cela remplacera la copie locale [2983] (qui, selon la citation ci-dessus, devrait être synchronisée avec le serveur – votre responsabilité) avec la révision 289 du serveur. Le changement se produit localement, ce qui signifie que si vous effectuez une vérification en bonne et due forme, les modifications peuvent être inspectées avant de les valider.

Ce qui suit a fonctionné pour moi.

J’ai eu beaucoup de changements locaux et j’ai dû éliminer ceux de la copie locale et extraire la dernière version stable de SVN.

  1. Vérifiez l’état de tous les fichiers, y compris les fichiers ignorés.

  2. Grep toutes les lignes pour obtenir les fichiers nouvellement ajoutés et ignorés.

  3. Remplacez ceux avec // .

  4. et rm -rf toutes les lignes.

    svn status –no-ignore | grep ‘^ [? I]’ | sed “s / ^ [? I] //” | xargs -I {} rm -rf “{}”