Meilleur moyen de faire le contrôle de version pour MS Excel

Quels systèmes de contrôle de version avez-vous utilisés avec MS Excel (2003/2007)? Que recommanderiez-vous et pourquoi? Quelles limitations avez-vous trouvées avec votre système de contrôle de version le mieux noté?

Pour mettre cela en perspective, voici quelques cas d'utilisation:

1. contrôle de version pour les modules VBA
2. plusieurs personnes travaillent sur une feuille de calcul Excel et peuvent apporter des modifications à la même feuille de calcul, qu'elles souhaitent fusionner et intégrer. Cette feuille de travail peut contenir des formules, des données, des graphiques, etc.
3. les utilisateurs ne sont pas trop techniques et moins il y a de systèmes de contrôle de version utilisés, mieux c'est
4. La contrainte d'espace est une considération. Idéalement, seules les modifications incrémentielles sont enregistrées plutôt que la feuille de calcul Excel entière.

Je viens de configurer une feuille de calcul qui utilise Bazaar, avec un check-in / out manuel via TortiseBZR. Étant donné que le sujet m'a aidé avec la partie de sauvegarde, je voulais publier ma solution ici.

La solution pour moi était de créer une feuille de calcul qui exporte tous les modules lors de l'enregistrement, et supprime et réimporte les modules à l'ouverture. Oui, cela peut être potentiellement dangereux pour la conversion de feuilles de calcul existantes.

Cela me permet d'éditer les macros dans les modules via Emacs (oui, emacs) ou nativement dans Excel, et de valider mon référentiel BZR après des changements majeurs. Étant donné que tous les modules sont des fichiers texte, les commandes standard de style diff dans BZR fonctionnent pour mes sources à l'exception du fichier Excel lui-même.

J'ai configuré un répertoire pour mon référentiel BZR, X: \ Data \ MySheet. Dans le dépôt se trouvent MySheet.xls et un fichier .vba pour chacun de mes modules (par exemple: Module1Macros). Dans ma feuille de calcul, j'ai ajouté un module qui est exempt du cycle d'exportation / importation appelé "VersionControl". Chaque module à exporter et à réimporter doit se terminer par "Macros".

Contenu du module "VersionControl":

Sub SaveCodeModules()

'This code Exports all VBA modules
Dim i%, sName$

With ThisWorkbook.VBProject
    For i% = 1 To .VBComponents.Count
        If .VBComponents(i%).CodeModule.CountOfLines > 0 Then
            sName$ = .VBComponents(i%).CodeModule.Name
            .VBComponents(i%).Export "X:\Tools\MyExcelMacros\" & sName$ & ".vba"
        End If
    Next i
End With

End Sub

Sub ImportCodeModules()

With ThisWorkbook.VBProject
    For i% = 1 To .VBComponents.Count

        ModuleName = .VBComponents(i%).CodeModule.Name

        If ModuleName <> "VersionControl" Then
            If Right(ModuleName, 6) = "Macros" Then
                .VBComponents.Remove .VBComponents(ModuleName)
                .VBComponents.Import "X:\Data\MySheet\" & ModuleName & ".vba"
           End If
        End If
    Next i
End With

End Sub

Ensuite, nous devons configurer des hooks d'événement pour ouvrir / enregistrer pour exécuter ces macros. Dans la visionneuse de code, faites un clic droit sur "ThisWorkbook" et sélectionnez "View Code". Vous devrez peut-être dérouler la zone de sélection en haut de la fenêtre de code pour passer de la vue «(Général)» à la vue «Classeur».

Contenu de la vue "Classeur":

Private Sub Workbook_Open()

ImportCodeModules

End Sub

Private Sub Workbook_BeforeSave(ByVal SaveAsUI As Boolean, Cancel As Boolean)

SaveCodeModules

End Sub

Je vais m'installer dans ce flux de travail au cours des prochaines semaines, et je posterai si j'ai des problèmes.

Merci d'avoir partagé le code VBComponent!

TortoiseSVN est un client Windows étonnamment bon pour le système de contrôle de version Subversion. Une caractéristique que je viens de découvrir est que lorsque vous cliquez pour obtenir une différence entre les versions d'un fichier Excel, cela ouvrira les deux versions dans Excel et mettra en évidence (en rouge) les cellules qui ont été modifiées. Cela se fait grâce à la magie d'un script vbs, décrit ici .

Vous pouvez trouver cela utile même si vous n'utilisez PAS TortoiseSVN.

Permettez-moi de résumer ce que vous souhaitez pour le contrôle de version et pourquoi:

1. Quoi:

   • Code (VBA)
   • Feuilles de calcul (formules)
   • Feuilles de calcul (valeurs)
   • Graphiques
   • ...

2. Pourquoi:

   • Journal d'audit
   • Collaboration
   • Comparaison de version ("différente")
   • Fusion

Comme d'autres l'ont posté ici, il existe quelques solutions en plus des systèmes de contrôle de version existants tels que:

• Git
• Mercuriel
• Subversion
• Bazar

Si votre seule préoccupation est le code VBA dans vos classeurs, alors l'approche proposée par Demosthenex ci-dessus ou VbaGit ( https://github.com/brucemcpherson/VbaGit ) fonctionne très bien et est relativement simple à mettre en œuvre. Les avantages sont que vous pouvez compter sur des systèmes de contrôle de version éprouvés et en choisir un en fonction de vos besoins (jetez un œil à https://help.github.com/articles/what-are-the-differences-between-svn-and -git / pour une brève comparaison entre Git et Subversion).

Si vous vous souciez non seulement du code, mais aussi des données de vos feuilles (valeurs "codées en dur" et résultats de formule), vous pouvez utiliser une stratégie similaire pour cela: Sérialiser le contenu de vos feuilles dans un format de texte (via Range.Value) et utiliser un système de contrôle de version existant. Voici un très bon article de blog à ce sujet: https://wiki.ucl.ac.uk/display/~ucftpw2/2013/10/18/Using+git+for+version+control+of+spreadsheet+models+-+part + 1 + sur + 3

Cependant, la comparaison de feuilles de calcul est un problème algorithmique non trivial. Il existe quelques outils, tels que Spreadsheet Compare de Microsoft ( https://support.office.com/en-us/article/Overview-of-Spreadsheet-Compare-13fafa61-62aa-451b-8674-242ce5f2c986 ), Exceldiff ( http://exceldiff.arstdesign.com/ ) et DiffEngineX ( https://www.florencesoft.com/compare-excel-workbooks-differences.html ). Mais c'est un autre défi d'intégrer ces comparaisons avec un système de contrôle de version comme Git.

Enfin, vous devez vous installer sur un workflow qui correspond à vos besoins. Pour un flux de travail Git pour Excel simple et personnalisé, consultez https://www.xltrail.com/blog/git-workflow-for-excel .

Cela dépend si vous parlez de données ou du code contenu dans une feuille de calcul. Bien que j'aie une forte aversion pour Visual Sourcesafe de Microsoft et que je ne le recommanderais normalement pas, il s'intègre facilement à la fois avec Access et Excel et fournit un contrôle de source des modules.

[En fait, l'intégration avec Access comprend des requêtes, des rapports et des modules en tant qu'objets individuels qui peuvent être versionnés]

Le lien MSDN est ici .

Je ne suis pas au courant d'un outil qui fait bien cela, mais j'ai vu une variété de solutions locales. Le fil conducteur de ces derniers est de minimiser les données binaires sous contrôle de version et de maximiser les données textuelles pour tirer parti de la puissance des systèmes scc conventionnels. Pour faire ça:

• Traitez le classeur comme n'importe quelle autre application. Logique, configuration et données séparées.
• Code séparé du classeur.
• Créez l'interface utilisateur par programme.
• Écrivez un script de construction pour reconstruire le classeur.

Travaillant sur le travail @Demosthenex, @Tmdean et @Jon Crowell des commentaires inestimables! (+1 eux)

J'enregistre les fichiers du module dans git \ dir à côté de l'emplacement du classeur. Changez cela à votre goût.

Cela ne suivra PAS les modifications apportées au code du classeur. C'est donc à vous de les synchroniser.

Sub SaveCodeModules()

'This code Exports all VBA modules
Dim i As Integer, name As String

With ThisWorkbook.VBProject
    For i = .VBComponents.count To 1 Step -1
        If .VBComponents(i).Type <> vbext_ct_Document Then
            If .VBComponents(i).CodeModule.CountOfLines > 0 Then
                name = .VBComponents(i).CodeModule.name
                .VBComponents(i).Export Application.ThisWorkbook.Path & _
                                            "\git\" & name & ".vba"
            End If
        End If
    Next i
End With

End Sub

Sub ImportCodeModules()
Dim i As Integer
Dim ModuleName As String

With ThisWorkbook.VBProject
    For i = .VBComponents.count To 1 Step -1

        ModuleName = .VBComponents(i).CodeModule.name

        If ModuleName <> "VersionControl" Then
            If .VBComponents(i).Type <> vbext_ct_Document Then
                .VBComponents.Remove .VBComponents(ModuleName)
                .VBComponents.Import Application.ThisWorkbook.Path & _
                                         "\git\" & ModuleName & ".vba"
            End If
        End If
    Next i
End With

End Sub

Et puis dans le module Workbook:

Private Sub Workbook_Open()

    ImportCodeModules

End Sub

Private Sub Workbook_BeforeSave(ByVal SaveAsUI As Boolean, Cancel As Boolean)

    SaveCodeModules

End Sub

En prenant la réponse de @Demosthenex un peu plus loin, si vous souhaitez également garder une trace du code dans vos objets Microsoft Excel et UserForms, vous devez être un peu difficile.

J'ai d'abord modifié ma SaveCodeModules()fonction pour tenir compte des différents types de code que je prévois d'exporter:

Sub SaveCodeModules(dir As String)

'This code Exports all VBA modules
Dim moduleName As String
Dim vbaType As Integer

With ThisWorkbook.VBProject
    For i = 1 To .VBComponents.count
        If .VBComponents(i).CodeModule.CountOfLines > 0 Then
            moduleName = .VBComponents(i).CodeModule.Name
            vbaType = .VBComponents(i).Type

            If vbaType = 1 Then
                .VBComponents(i).Export dir & moduleName & ".vba"
            ElseIf vbaType = 3 Then
                .VBComponents(i).Export dir & moduleName & ".frm"
            ElseIf vbaType = 100 Then
                .VBComponents(i).Export dir & moduleName & ".cls"
            End If

        End If
    Next i
End With

End Sub

Les UserForms peuvent être exportés et importés comme le code VBA. La seule différence est que deux fichiers seront créés lors de l'exportation d'un formulaire (vous obtiendrez .frmun .frxfichier et un fichier pour chaque UserForm). L'un d'entre eux contient le logiciel que vous avez écrit et l'autre est un fichier binaire qui (j'en suis presque sûr) définit la disposition du formulaire.

Objets Microsoft Excel (OPE) ( ce qui signifie Sheet1, Sheet2, ThisWorkbooketc.) peuvent être exportés en tant que .clsfichier. Cependant, lorsque vous souhaitez récupérer ce code dans votre classeur, si vous essayez de l'importer de la même manière qu'un module VBA, vous obtiendrez une erreur si cette feuille existe déjà dans le classeur.

Pour contourner ce problème, j'ai décidé de ne pas essayer d'importer le fichier .cls dans Excel, mais .clsplutôt de lire le fichier dans Excel sous forme de chaîne, puis de coller cette chaîne dans le MEO vide. Voici mes ImportCodeModules:

Sub ImportCodeModules(dir As String)

Dim modList(0 To 0) As String
Dim vbaType As Integer

' delete all forms, modules, and code in MEOs
With ThisWorkbook.VBProject
    For Each comp In .VBComponents

        moduleName = comp.CodeModule.Name

        vbaType = .VBComponents(moduleName).Type

        If moduleName <> "DevTools" Then
            If vbaType = 1 Or _
                vbaType = 3 Then

                .VBComponents.Remove .VBComponents(moduleName)

            ElseIf vbaType = 100 Then

                ' we can't simply delete these objects, so instead we empty them
                .VBComponents(moduleName).CodeModule.DeleteLines 1, .VBComponents(moduleName).CodeModule.CountOfLines

            End If
        End If
    Next comp
End With

' make a list of files in the target directory
Set FSO = CreateObject("Scripting.FileSystemObject")
Set dirContents = FSO.getfolder(dir) ' figure out what is in the directory we're importing

' import modules, forms, and MEO code back into workbook
With ThisWorkbook.VBProject
    For Each moduleName In dirContents.Files

        ' I don't want to import the module this script is in
        If moduleName.Name <> "DevTools.vba" Then

            ' if the current code is a module or form
            If Right(moduleName.Name, 4) = ".vba" Or _
                Right(moduleName.Name, 4) = ".frm" Then

                ' just import it normally
                .VBComponents.Import dir & moduleName.Name

            ' if the current code is a microsoft excel object
            ElseIf Right(moduleName.Name, 4) = ".cls" Then
                Dim count As Integer
                Dim fullmoduleString As String
                Open moduleName.Path For Input As #1

                count = 0              ' count which line we're on
                fullmoduleString = ""  ' build the string we want to put into the MEO
                Do Until EOF(1)        ' loop through all the lines in the file

                    Line Input #1, moduleString  ' the current line is moduleString
                    If count > 8 Then            ' skip the junk at the top of the file

                        ' append the current line `to the string we'll insert into the MEO
                        fullmoduleString = fullmoduleString & moduleString & vbNewLine

                    End If
                    count = count + 1
                Loop

                ' insert the lines into the MEO
                .VBComponents(Replace(moduleName.Name, ".cls", "")).CodeModule.InsertLines .VBComponents(Replace(moduleName.Name, ".cls", "")).CodeModule.CountOfLines + 1, fullmoduleString

                Close #1

            End If
        End If

    Next moduleName
End With

End Sub

Au cas où vous seriez confus par l' direntrée de ces deux fonctions, ce n'est que votre référentiel de code! Donc, vous appelleriez ces fonctions comme:

SaveCodeModules "C:\...\YourDirectory\Project\source\"
ImportCodeModules "C:\...\YourDirectory\Project\source\"

J'utilise git , et aujourd'hui j'ai porté ceci (git-xlsx-textconv) sur Python, car mon projet est basé sur du code Python, et il interagit avec les fichiers Excel. Cela fonctionne pour au moins .xlsx fichiers , mais je pense que cela fonctionnera aussi pour .xls . Voici le lien github. J'ai écrit deux versions, une avec chaque ligne sur sa propre ligne, et une autre où chaque cellule est sur sa propre ligne (cette dernière a été écrite parce que git diff n'aime pas envelopper de longues lignes par défaut, du moins ici sous Windows).

Ceci est mon fichier .gitconfig (cela permet au script différent de résider dans le dépôt de mon projet):

[diff "xlsx"]
    binary = true
    textconv = python `git rev-parse --show-toplevel`/src/util/git-xlsx-textconv.py

si vous voulez que le script soit disponible pour de nombreux dépôts différents, utilisez quelque chose comme ceci:

[diff "xlsx"]
    binary = true
    textconv = python C:/Python27/Scripts/git-xlsx-textconv.py

mon fichier .gitattributes :

*.xlsx diff=xlsx

Une chose que vous pouvez faire est d'avoir l'extrait de code suivant dans votre classeur:

Sub SaveCodeModules()

'This code Exports all VBA modules
Dim i%, sName$

    With ThisWorkbook.VBProject
        For i% = 1 To .VBComponents.Count
            If .VBComponents(i%).CodeModule.CountOfLines > 0 Then
                sName$ = .VBComponents(i%).CodeModule.Name
                .VBComponents(i%).Export "C:\Code\" & sName$ & ".vba"
            End If
        Next i
    End With
End Sub

J'ai trouvé cet extrait sur Internet.

Ensuite, vous pouvez utiliser Subversion pour maintenir le contrôle de version. Par exemple en utilisant l'interface de ligne de commande de Subversion avec la commande «shell» dans VBA. Cela le ferait. Je pense même faire ça moi-même :)

Je voudrais recommander un excellent outil open-source appelé Rubberduck qui a un contrôle de version du code VBA intégré. Essayez-le!

Si vous recherchez un environnement de bureau avec des utilisateurs non techniques de bureau réguliers, Sharepoint est une alternative viable. Vous pouvez configurer des dossiers de documents avec le contrôle de version activé et les archivages et extractions. Le rend plus convivial pour les utilisateurs de bureau réguliers.

en réponse à la réponse de mattlant - sharepoint fonctionnera bien comme contrôle de version uniquement si la fonction de contrôle de version est activée dans la bibliothèque de documents. en outre, sachez que tout code qui appelle d'autres fichiers par des chemins relatifs ne fonctionnera pas. et enfin tous les liens vers des fichiers externes seront rompus lorsqu'un fichier est enregistré dans sharepoint.

Utilisez l'un des outils de contrôle de version standard tels que SVN ou CVS. Les limitations dépendraient de quel est l'objectif. Mis à part une petite augmentation de la taille du référentiel, je n'ai rencontré aucun problème

Vous devriez essayer DiffEngineX. Il peut être appelé par programme et aussi à partir de la ligne de commande en prenant des arguments de ligne de commande. Il compare non seulement les cellules des feuilles de calcul Excel, mais également les macros Visual Basic incorporées dans les classeurs. Compare également les noms et les commentaires définis par Excel, que de nombreux outils gratuits manquent. Il peut être téléchargé depuis

http://www.florencesoft.com/excel-differences-download.html

Je suis sûr que votre système de contrôle de version dispose d'une option ou d'une boîte pour que vous puissiez appeler automatiquement DiffEngineX avec vos classeurs Excel originaux et modifiés.

J'ai aussi étudié cela. Il apparaît que le dernier Team Foundation Server 2010 peut avoir un complément Excel.

Voici un indice:

http://team-foundation-server.blogspot.com/2009/07/tf84037-there-was-problem-initializing.html

Après avoir recherché des âges et essayé de nombreux outils différents, j'ai trouvé ma réponse au problème de contrôle de version de vba ici: https://stackoverflow.com/a/25984759/2780179

C'est un simple addin Excel pour lequel le code peut être trouvé ici

Il n'y a pas de modules en double après l'importation. Il exporte votre code automatiquement, dès que vous enregistrez votre classeur, sans modifier aucun classeur existant . Il vient avec un formateur de code vba.

En fait, il n'y a qu'une poignée de solutions pour suivre et comparer les modifications du code macro - la plupart d'entre elles ont déjà été nommées ici. J'ai navigué sur le Web et suis tombé sur ce nouvel outil qui mérite d'être mentionné:

Contrôle de version XLTools pour les macros VBA

• contrôle de version pour les feuilles Excel et les modules VBA
• prévisualiser et modifier les différences avant de valider une version
• idéal pour le travail collaboratif de plusieurs utilisateurs sur le même fichier (suivre qui a changé quoi / quand / commentaires)
• comparer les versions et mettre en évidence les changements de code ligne par ligne
• convient aux utilisateurs qui ne sont pas férus de technologie, ou qui ne maîtrisent pas Excel d'ailleurs
• l'historique des versions est stocké dans le référentiel Git sur votre propre PC - n'importe quelle version peut être facilement récupérée

Versions de code VBA côte à côte, les changements sont visualisés

Vous avez peut-être essayé d'utiliser le XML Excel de Microsoft dans le conteneur zip (.xlsx et .xslm) pour le contrôle de version et constaté que le vba était stocké dans vbaProject.bin (ce qui est inutile pour le contrôle de version).

La solution est simple.

1. Ouvrez le fichier Excel avec LibreOffice Calc
2. Dans LibreOffice Calc
   1. Fichier
   2. Enregistrer sous
   3. Enregistrer sous le type: Feuille de calcul ODF (.ods)
3. Fermer LibreOffice Calc
4. renommer l'extension de fichier du nouveau fichier de .ods en .zip
5. créer un dossier pour la feuille de calcul dans une zone gérée par GIT
6. extraire le zip dans son dossier GIT
7. s'engager dans GIT

Lorsque vous répétez cela avec la prochaine version de la feuille de calcul, vous devrez vous assurer que les fichiers du dossier correspondent exactement à ceux du conteneur zip (et ne laissez aucun fichier supprimé).

Il existe également un programme appelé Beyond Compare qui propose une comparaison de fichiers Excel assez intéressante. J'ai trouvé une capture d'écran en chinois qui montre brièvement ceci:

Source d'image originale

Il y a un essai de 30 jours sur leur page

J'ai trouvé une solution très simple à cette question qui répond à mes besoins. J'ajoute une ligne au bas de toutes mes macros qui exporte un *.txtfichier avec le code de macro entier à chaque fois qu'il est exécuté. Le code:

ActiveWorkbook.VBProject.VBComponents("moduleName").Export"C:\Path\To\Spreadsheet\moduleName.txt"

(Trouvé sur les didacticiels de Tom , qui couvre également certaines configurations dont vous pourriez avoir besoin pour que cela fonctionne.)

Puisque je vais toujours exécuter la macro chaque fois que je travaille sur le code, je suis assuré que git prendra les modifications. La seule partie ennuyeuse est que si je dois récupérer une version antérieure, je dois copier / coller manuellement depuis le *.txtdans la feuille de calcul.

Cela dépend du niveau d'intégration que vous souhaitez, j'ai utilisé Subversion / TortoiseSVN qui semble bien pour une utilisation simple. J'ai également ajouté des mots-clés mais il semble y avoir un risque de corruption de fichier. Il existe une option dans Subversion pour rendre les substitutions de mots-clés de longueur fixe et pour autant que je sache, cela fonctionnera si la longueur fixe est paire mais pas impaire. Dans tous les cas, vous n'obtenez aucune fonctionnalité de diff, je pense qu'il existe des produits commerciaux qui feront des «diff». J'ai trouvé quelque chose qui différait en convertissant des éléments en texte brut et en les comparant, mais ce n'était pas très agréable.

Il devrait fonctionner avec la plupart des VCS (en fonction d'autres critères, vous pouvez choisir SVN, CVS, Darcs, TFS, etc.), mais il s'agira en fait du fichier complet (car il s'agit d'un format binaire), ce qui signifie que la question «ce qui a changé» est pas si facile de répondre.

Vous pouvez toujours compter sur les messages du journal si les gens les remplissent, mais vous pouvez également essayer les nouveaux formats basés sur XML d'Office 2007 pour gagner en visibilité (même s'il serait toujours difficile d'éliminer les tonnes de XML, plus AFAIK le fichier XML est compressé sur le disque, vous auriez donc besoin d'un hook de pré-validation pour le décompresser pour que la différence de texte fonctionne correctement).

J'ai écrit une feuille de calcul contrôlée par révision en utilisant VBA. Il est davantage destiné aux rapports d'ingénierie où plusieurs personnes travaillent sur une nomenclature ou un calendrier, puis à un moment donné, vous souhaitez créer une révision d'instantané qui montre les ajouts, les suppressions et les mises à jour de la version précédente.

Remarque: il s'agit d'un classeur prenant en charge les macros que vous devez vous connecter pour télécharger depuis mon site (vous pouvez utiliser OpenID)

Tout le code est déverrouillé.

Feuille de calcul contrôlée par révision

Mon entreprise fait un travail considérable dans l'automatisation des solutions Microsoft Office, j'ai donc écrit un .DLL qui exportera la source d'une solution à chaque fois qu'un modèle est enregistré. Il crée un dossier nommé Source en tant qu'enfant du dossier dans lequel le modèle est enregistré, et sous Source, il crée un dossier portant le même nom que le projet VBA. Dans le dossier du projet, il exporte tout le code source des modules, des classes et des formulaires utilisateur. Cette disposition a été choisie pour faciliter la gestion de la source de grandes collections de modèles. La DLL est capable de déverrouiller des projets verrouillés pour accéder au projet VBA si vous disposez d'un fichier de configuration local ou d'un fichier de configuration globale. Avec cet outil utilisé, les développeurs peuvent travailler sur des modèles à leur guise et utiliser leur outil de contrôle de révision préféré pour gérer leur travail.