La mejor manera de hacer control de versiones para MS Excel

¿Qué sistemas de control de versiones ha usado con MS Excel (2003/2007)? ¿Que recomendaria y porque? ¿Qué limitaciones ha encontrado con su sistema de control de versión mejor valorado?

Para poner esto en perspectiva, aquí hay un par de casos de uso:

  1. control de versión para modules VBA
  2. más de una persona está trabajando en una spreadsheet de Excel y pueden estar haciendo cambios en la misma hoja de trabajo, que desean fusionar e integrar. Esta hoja de trabajo puede tener fórmulas, datos, charts, etc.
  3. los usuarios no son demasiado técnicos y cuantos less sistemas de control de versiones usaron mejor
  4. La restricción de espacio es una consideración. Idealmente, solo se guardan los cambios incrementales en lugar de la spreadsheet de Excel completa.

Acabo de configurar una spreadsheet que usa Bazaar, con checkin / out manual a través de TortiseBZR. Dado que el tema me ayudó con la porción de salvar, quería publicar mi solución aquí.

La solución para mí fue crear una spreadsheet que exporte todos los modules al save, y elimine y vuelva a importar los modules en abierto. Sí, esto podría ser potencialmente peligroso para convertir hojas de cálculo existentes.

Esto me permite editar las macros en los modules a través de Emacs (sí, emacs) o de forma nativa en Excel, y confirmar mi repository BZR después de cambios importantes. Debido a que todos los modules son files de text, los commands estándar de estilo diff en BZR funcionan para mis fonts, excepto el file Excel en sí.

He configurado un directory para mi repository BZR, X: \ Data \ MySheet. En el repository se encuentran MySheet.xls y un file .vba para cada uno de mis modules (es decir, Module1Macros). En mi spreadsheet, agregué un module que está exento del ciclo de export / import llamado "VersionControl". Cada module que se exportará y reimportará debe terminar en "Macros".

Contenido del 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 

A continuación, tenemos que configurar ganchos de events para abrir / save para ejecutar estas macros. En el visor de código, haga clic derecho en "ThisWorkbook" y select "Ver código". Puede tener que desplegar el cuadro de selección en la parte superior de la window de código para cambiar de la vista "(General)" a la vista "Libro de trabajo".

Contenido de la vista "Libro de trabajo":

 Private Sub Workbook_Open() ImportCodeModules End Sub Private Sub Workbook_BeforeSave(ByVal SaveAsUI As Boolean, Cancel As Boolean) SaveCodeModules End Sub 

Me instalaré en este flujo de trabajo en las próximas semanas y publicaré si tengo algún problema.

¡Gracias por compartir el código de VBComponent!

TortoiseSVN es un cliente de Windows asombrosamente bueno para el sistema de control de versiones de Subversion. Una característica que acabo de descubrir que tiene es que cuando hace clic para get una diferencia entre las versiones de un file de Excel, abrirá ambas versiones en Excel y resaltará (en rojo) las celdas que se cambiaron. Esto se hace a través de la magia de un script vbs, que se describe aquí .

Puede encontrar esto útil aunque NO use TortoiseSVN.

Depende de si está hablando de datos o del código contenido en una spreadsheet. Si bien tengo una fuerte aversión a Visual Sourcesafe de Microsoft y normalmente no lo recomendaría, se integra fácilmente con Access y Excel, y proporciona control de fuente de los modules.

[De hecho, la integración con Access incluye consultas, informes y modules como objects individuales que se pueden versionar]

El enlace de MSDN está aquí .

No conozco una herramienta que lo haga bien, pero he visto una variedad de soluciones de cosecha propia. El hilo común de estos es minimizar los datos binarys bajo control de versión y maximizar los datos textuales para aprovechar la potencia de los sistemas scc convencionales. Para hacer esto:

  • Trate el libro de trabajo como cualquier otra aplicación. Separa la lógica, la configuration y los datos.
  • Separe el código del libro de trabajo.
  • Construye la interfaz de usuario programáticamente.
  • Escriba un script de compilation para rebuild el libro de trabajo.

Permítame resumir lo que le gustaría controlar de la versión y por qué:

  1. Qué:

    • Código (VBA)
    • Hojas de cálculo (fórmulas)
    • Hojas de cálculo (valores)
    • Gráficos
  2. Por qué:

    • Registro de auditoría
    • Colaboración
    • Comparación de versión ("diferente")
    • Fusión

Como otros han publicado aquí, hay un par de soluciones sobre los sistemas de control de versiones existentes, tales como:

  • Git
  • Mercurial
  • Subversión
  • Bazar

Si su única preocupación es el código VBA en sus libros de trabajo, entonces el enfoque propuesto por Demosthenex más arriba o VbaGit ( https://github.com/brucemcpherson/VbaGit ) funcionan muy bien y son relativamente simples de implementar. Las ventajas son que puede confiar en los sistemas de control de versiones bien probados y elegir uno según sus necesidades (consulte https://help.github.com/articles/what-are-the-differences-between-svn-and -git / para una breve comparación entre Git y Subversion).

Si no solo se preocupa por el código sino también por los datos en sus hojas (valores "codificados" y resultados de fórmula), puede usar una estrategia similar para eso: serializar los contenidos de sus hojas en algún formatting de text (a través de Range.Value) y use un sistema de control de versiones existente. Aquí hay una muy buena publicación de blog sobre esto: https://wiki.ucl.ac.uk/display/~ucftpw2/2013/10/18/Using+git+for+version+control+of+supdateheet+models+-+part + 1 + de + 3

Sin embargo, la comparación de spreadsheet es un problema algorítmico no trivial. Existen algunas herramientas, como la comparación de spreadsheet de Microsoft ( https://support.office.com/en-us/article/Overview-of-Spreadsheet-Compare-13fafa61-62aa-451b-8674-242ce5f2c986 ), Exceldiff ( http://exceldiff.arstdesign.com/ ) y DiffEngineX ( https://www.florencesoft.com/compare-excel-workbooks-differences.html ). Pero es otro desafío integrar estas comparaciones con un sistema de control de versiones como Git.

Finalmente, debe establecer un flujo de trabajo que se adapte a sus necesidades. Para get un flujo de trabajo simple y adaptado de Git for Excel, consulte https://www.xltrail.com/blog/git-workflow-for-excel .

Trabajando sobre el trabajo de @Demosthenex, @Tmdean y @Jon Crowell comentarios invaluables! (+1 ellos)

Guardo files de module en git \ dir al lado de la location del libro. Cambia eso a tu gusto.

Esto NO rastreará los cambios al código del Libro de trabajo. Entonces depende de usted sincronizarlos.

 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 

Y luego en el module Libro de trabajo:

 Private Sub Workbook_Open() ImportCodeModules End Sub Private Sub Workbook_BeforeSave(ByVal SaveAsUI As Boolean, Cancel As Boolean) SaveCodeModules End Sub 

Tomando la respuesta de @Demosthenex un paso más allá, si también desea realizar un seguimiento del código en sus Objetos de Microsoft Excel y UserForms tiene que ser un poco complicado.

Primero modifiqué mi function SaveCodeModules() para dar count de los diferentes types de código que planeo exportar:

 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 

Los UserForms se pueden exportar e importar como el código VBA. La única diferencia es que se crearán dos files cuando se exporte un formulario (obtendrá un .frm y un file .frx para cada UserForm). Uno de ellos contiene el software que ha escrito y el otro es un file binary que (estoy bastante seguro) define el layout del formulario.

Los Objetos de Microsoft Excel (MEO) (es decir, Sheet1 , Sheet2 , ThisWorkbook , etc.) se pueden exportar como un file .cls . Sin embargo, cuando desee volver a introducir este código en su libro de trabajo, si intenta importarlo de la misma manera que lo haría con un module de VBA, obtendrá un error si esa hoja ya existe en el libro de trabajo.

Para evitar este problema, decidí no intentar importar el file .cls en Excel, pero para leer el file .cls en Excel como una cadena en su lugar, luego pegar esta cadena en el MEO vacío. Aquí está mi 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 

En caso de que esté confundido por la input del dir a estas dos funciones, ¡ese es solo su repository de código! Entonces, llamarías a estas funciones como:

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

Una cosa que podría hacer es tener el siguiente fragment en su Libro de trabajo:

 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 

Encontré este fragment en Internet.

Después, puede usar Subversion para mantener el control de la versión. Por ejemplo, al usar la interfaz de línea de command de Subversion con el command 'shell' dentro de VBA. Eso lo haría. Incluso estoy pensando en hacer esto yo mismo 🙂

Yo uso git , y hoy porté esto (git-xlsx-textconv) a Python, ya que mi proyecto se basa en el código de Python e interactúa con files de Excel. Esto funciona para al less files .xlsx , pero creo que funcionará para .xls también. Aquí está el enlace de Github. Escribí dos versiones, una con cada fila en su propia línea, y otra donde cada celda está en su propia línea (esta última se escribió porque a git diff no le gusta ajustar líneas largas de forma pnetworkingeterminada, al less aquí en Windows).

Este es mi file .gitconfig (esto permite que el script diferente resida en el repository de mi proyecto):

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

si desea que el script esté disponible para muchos repositorys diferentes, use algo como esto:

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

mi file .gitattributes :

 *.xlsx diff=xlsx 

Utilice cualquiera de las herramientas de control de versiones estándar como SVN o CVS. Las limitaciones dependerán de cuál sea el objective. Además de un pequeño aumento en el tamaño del repository, no tuve problemas

Si está buscando un entorno de oficina con usuarios no técnicos regulares de la oficina, Sharepoint es una alternativa viable. Puede configurar carpetas de documentos con control de versiones habilitado y checkins y checkouts. Lo hace más fácil para los usuarios habituales de la oficina.

en respuesta a la respuesta de mattlant, sharepoint funcionará bien como control de versión solo si la característica de control de versión está activada en la biblioteca de documentos. Además, tenga en count que ningún código que llame a otros files por routes relativas no funcionará. y, finalmente, cualquier enlace a files externos se romperá cuando se guarde un file en sharepoint.

Deberías probar DiffEngineX. Puede llamarse programáticamente y también desde la command-line tomando arguments de línea de command. No solo compara las celdas de hojas de cálculo de Excel, sino también las macros de Visual Basic incrustadas en los libros de trabajo. También compara nombres y comentarios definidos de Excel, que muchas herramientas de software gratuito se pierden. Se puede download de

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

Estoy seguro de que su sistema de control de versiones tiene una opción o cuadro para que pueda llamar automáticamente a DiffEngineX con sus libros de Excel originales y modificados.

He estado investigando esto también. Parece que el último Team Foundation Server 2010 puede tener un complemento de Excel.

Aquí hay una pista:

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

Después de search por años y probar muchas herramientas diferentes, he encontrado mi respuesta al problema de control de versión vba aquí: http://sofes.miximages.com/a/25984759/2780179

Es un simple complemento de Excel para el cual se puede encontrar el código aquí

No hay modules duplicates después de la import. Exporta su código automáticamente, tan pronto como guarde su libro de trabajo, sin modificar ninguno de los libros existentes . Viene junto con un formateador de código vba.

En realidad, solo hay un puñado de soluciones para rastrear y comparar los cambios en el código de macro, la mayoría de ellos ya se mencionaron aquí. He estado navegando por la web y encontré esta nueva herramienta que vale la pena mencionar:

Control de versiones XLTools para macros de VBA

  • control de versiones para hojas de Excel y modules de VBA
  • vista previa y cambios de diferencias antes de comprometer una versión
  • ideal para el trabajo queueborativo de varios usuarios en el mismo file (rastrear quién cambió qué / cuándo / comentarios)
  • comparar versiones y resaltar los cambios en el código línea por línea
  • adecuado para usuarios que no son conocedores de la tecnología o conocedores de Excel para el caso
  • el historial de versiones se almacena en Git-repository en su propia PC; cualquier versión puede recuperarse fácilmente

Versiones de código VBA una al lado de la otra, los cambios se visualizan

Es posible que haya intentado utilizar el XML de Excel de Microsoft en el contenedor zip (.xlsx y .xslm) para el control de versiones y haya encontrado que la vba se almacenó en vbaProject.bin (que es inútil para el control de versiones).

La solución es simple.

  1. Abra el file Excel con LibreOffice Calc
  2. En LibreOffice Calc
    1. Archivo
    2. Guardar como
    3. Guardar como tipo: Hoja de cálculo ODF (.ods)
  3. Cerrar LibreOffice Calc
  4. cambiar el nombre de la extensión del file nuevo de .ods a .zip
  5. crear una carpeta para la spreadsheet en un área mantenida por GIT
  6. extraer el zip en su carpeta GIT
  7. comprometerse con GIT

Cuando repita esto con la próxima versión de la spreadsheet, deberá asegurarse de que los files de la carpeta coincidan exactamente con los del contenedor zip (y no deje ningún file eliminado).

También hay un progtwig llamado Beyond Compare que tiene un file de Excel bastante bueno. Encontré una captura de pantalla en chino que muestra brevemente esto:

Más allá de Comparar: comparando dos archivos de Excel (chino)
Fuente de la image original

Hay una testing de 30 días en su página

Mi empresa hace una cantidad considerable de trabajo para automatizar las soluciones de Microsoft Office, así que escribí un .DLL que exportará el origen de una solución cada vez que se guarde una plantilla. Crea una carpeta llamada Source como elemento secundario de la carpeta donde se guarda la plantilla, y debajo de Source crea una carpeta con el mismo nombre que el Proyecto VBA. En la carpeta del proyecto, exporta todo el código fuente para modules, classs y formularios de usuario. Esta disposition se eligió para facilitar la administración de la fuente de grandes collections de templates. La DLL puede desbloquear proyectos bloqueados para get acceso al proyecto VBA si tiene un file de configuration local o un file de configuration global disponible. Con esta herramienta en uso, los desarrolladores pueden trabajar en templates al máximo contenido y usar su herramienta de control de revisiones favorita para administrar su trabajo. Usamos Git principalmente en nuestro entorno y mantenemos los files binarys de la plantilla completa, así como los resources de VBA bajo control de revisión.

Me gustaría recomendar una gran herramienta de código abierto llamada Rubberduck que tiene el control de versión del código VBA incorporado. ¡Pruébalo!

Depende del nivel de integración que desee, he usado Subversion / TortoiseSVN, que parece estar bien para un uso simple. También agregué palabras key, pero parece haber un riesgo de corrupción de files. Existe una opción en Subversion para hacer que las sustituciones de palabras key tengan una duración fija y, por lo que yo entiendo, funcionarán si la longitud fija es par, pero no impar. En cualquier caso, no obtiene ningún tipo de funcionalidad útil, creo que hay productos comerciales que harán 'diff'. Encontré algo que hizo diferencias basado en convertir cosas a text plano y comparar eso, pero no fue muy agradable.

Debería funcionar con la mayoría de VCS (dependiendo de otros criterios, puede elegir SVN, CVS, Darcs, TFS, etc.), pero en realidad será el file completo (porque es un formatting binary), lo que significa que la pregunta "¿qué cambió? no tan fácil de responder.

Todavía puede confiar en los posts de logging si las personas los completan, pero también puede probar los nuevos formattings basados ​​en XML de Office 2007 para get más visibilidad (aunque todavía sería difícil eliminar las toneladas de XML, además de AFAIK el file XML) está comprimido en el disco, por lo que necesitaría un gancho precompromiso para descomprimirlo para que la diferencia de text funcione correctamente).

Escribí una spreadsheet controlada por revisión usando VBA. Está más orientado a informes de ingeniería donde tienes varias personas trabajando en una list de materiales o progtwigción y luego, en algún momento, quieres crear una revisión instantánea que muestre las adiciones, del y las actualizaciones de la versión anterior.

Nota: es un libro de trabajo macro habilitado al que debe iniciar session para downloadlo de mi sitio (puede usar OpenID)

Todo el código está desbloqueado.

Rev Hoja de cálculo controlada