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 versiones mejor calificado?

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

1. control de versiones para módulos VBA
2. más de una persona está trabajando en una hoja de cálculo 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, gráficos, etc.
3. los usuarios no son demasiado técnicos y cuantos menos sistemas de control de versiones utilicen, mejor
4. La restricción de espacio es una consideración. Idealmente, solo se guardan los cambios incrementales en lugar de toda la hoja de cálculo de Excel.

Acabo de configurar una hoja de cálculo que usa Bazaar, con registro / salida manual a través de TortiseBZR. Dado que el tema me ayudó con la parte de guardar, quería publicar mi solución aquí.

La solución para mí fue crear una hoja de cálculo que exporta todos los módulos al guardar, y elimina y vuelve a importar los módulos en abierto. Sí, esto podría ser potencialmente peligroso para convertir hojas de cálculo existentes.

Esto me permite editar las macros en los módulos a través de Emacs (sí, emacs) o de forma nativa en Excel, y confirmar mi repositorio BZR después de cambios importantes. Como todos los módulos son archivos de texto, los comandos estándar de estilo diff en BZR funcionan para mis fuentes, excepto el archivo Excel en sí.

He configurado un directorio para mi repositorio BZR, X: \ Data \ MySheet. En el repositorio están MySheet.xls y un archivo .vba para cada uno de mis módulos (es decir: Module1Macros). En mi hoja de cálculo he agregado un módulo que está exento del ciclo de exportación / importación llamado "VersionControl". Cada módulo que se va a exportar y reimportar debe terminar en "Macros".

Contenido del módulo "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 enlaces de eventos para abrir / guardar para ejecutar estas macros. En el visor de código, haga clic derecho en "ThisWorkbook" y seleccione "Ver código". Es posible que deba desplegar el cuadro de selección en la parte superior de la ventana 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 durante 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 sorprendentemente bueno para el sistema de control de versiones Subversion. Una característica que acabo de descubrir que tiene es que cuando hace clic para obtener una diferencia entre las versiones de un archivo 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, descrito aquí .

Puede resultarle útil incluso si NO utiliza TortoiseSVN.

Permítanme resumir lo que le gustaría controlar 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 versiones ("diffing")
   • Fusionando

Como otros han publicado aquí, hay un par de soluciones además de 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 que Demosthenex propone anteriormente o VbaGit ( https://github.com/brucemcpherson/VbaGit ) funcionan muy bien y son relativamente simples de implementar. Las ventajas son que puede confiar en sistemas de control de versiones bien probados y elegir uno de acuerdo con 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órmulas), puede usar una estrategia similar para eso: serializar el contenido de sus hojas en algún formato de texto (a través de Range.Value) y usar 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+spreadsheet+models+-+part + 1 + de + 3

Sin embargo, la comparación de hojas de cálculo es un problema algorítmico no trivial. Existen algunas herramientas, como la Comparación de hojas de cálculo 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 conformarse con un flujo de trabajo que se adapte a sus necesidades. Para un flujo de trabajo Git for Excel simple y personalizado, eche un vistazo a https://www.xltrail.com/blog/git-workflow-for-excel .

Depende de si se trata de datos o del código contenido en una hoja de cálculo. Si bien tengo un fuerte disgusto por Visual Sourcesafe de Microsoft y normalmente no lo recomendaría, se integra fácilmente tanto con Access como con Excel, y proporciona control de fuente de los módulos.

[De hecho, la integración con Access incluye consultas, informes y módulos como objetos 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 locales. El hilo común de estos es minimizar los datos binarios bajo el control de versiones y maximizar los datos textuales para aprovechar el poder de los sistemas SCC convencionales. Para hacer esto:

• Trate el libro de trabajo como cualquier otra aplicación. Lógica separada, configuración y datos.
• Código separado del libro de trabajo.
• Construya la IU mediante programación.
• Escriba un script de compilación para reconstruir el libro de trabajo.

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

Guardo los archivos del módulo en git \ dir junto a la ubicación del libro. Cambia eso a tu gusto.

Esto NO hará un seguimiento de los cambios en el 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 módulo Libro de trabajo:

Private Sub Workbook_Open()

    ImportCodeModules

End Sub

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

    SaveCodeModules

End Sub

Llevando la respuesta de @Demosthenex un paso más allá, si desea realizar un seguimiento del código en sus Objetos de Microsoft Excel y Formularios de usuario, debe ponerse un poco complicado.

Primero modifiqué mi SaveCodeModules()función para tener en cuenta los diferentes tipos 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 al igual que el código VBA. La única diferencia es que se crearán dos archivos cuando se exporte un formulario (obtendrá un .frmy un .frxarchivo para cada UserForm). Uno de ellos contiene el software que ha escrito y el otro es un archivo binario que (estoy bastante seguro) define el diseño del formulario.

Microsoft Excel Objetos (MEO) (que significa Sheet1, Sheet2, ThisWorkbooketc.) se pueden exportar como un .clsarchivo. Sin embargo, cuando desee recuperar este código en su libro de trabajo, si intenta importarlo de la misma manera que lo haría con un módulo VBA, recibirá un error si esa hoja ya existe en el libro de trabajo.

Para solucionar este problema, decidí no intentar importar el archivo .cls a Excel, sino leer el .clsarchivo en Excel como una cadena, y 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 direntrada a ambas funciones, ¡ese es solo su repositorio de código! Entonces, llamarías a estas funciones como:

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

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 archivos de Excel. Esto funciona para al menos archivos .xlsx , pero creo que también funcionará para .xls . 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 (la última se escribió porque a git diff no le gusta ajustar las líneas largas de forma predeterminada, al menos aquí en Windows).

Este es mi archivo .gitconfig (esto permite que el script diferente resida en el repositorio 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 repositorios diferentes, use algo como esto:

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

mi archivo .gitattributes :

*.xlsx diff=xlsx

Una cosa que podría hacer es tener el siguiente fragmento 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 fragmento en Internet.

Luego, puede usar Subversion para mantener el control de la versión. Por ejemplo, utilizando la interfaz de línea de comandos de Subversion con el comando 'shell' dentro de VBA. Eso lo haría. Incluso estoy pensando en hacer esto yo mismo :)

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

Si está buscando un entorno de oficina con usuarios no técnicos de oficina regulares, Sharepoint es una alternativa viable. Puede configurar carpetas de documentos con control de versiones habilitado y registros y salidas. Lo hace más sencillo 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 función de control de versión está activada en la biblioteca de documentos. Además, tenga en cuenta que cualquier código que llame a otros archivos por rutas relativas no funcionará. y finalmente cualquier enlace a archivos externos se romperá cuando se guarde un archivo en sharepoint.

Utilice cualquiera de las herramientas de control de versiones estándar como SVN o CVS. Las limitaciones dependerán de cuál sea el objetivo. Aparte de un pequeño aumento en el tamaño del repositorio, no tuve ningún problema

Deberías probar DiffEngineX. Se puede llamar mediante programación y también desde la línea de comandos tomando argumentos de la línea de comandos. No solo compara las celdas de las hojas de cálculo de Excel, sino también las macros de Visual Basic incrustadas en los libros. También compara los nombres y comentarios definidos por Excel, que muchas herramientas freeware pierden. Se puede descargar desde

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 buscar edades y probar muchas herramientas diferentes, he encontrado mi respuesta al problema de control de versiones de vba aquí: https://stackoverflow.com/a/25984759/2780179

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

No hay módulos duplicados después de la importación. Exporta su código automáticamente, tan pronto como guarde su libro de trabajo, sin modificar ningún libro de trabajo existente . Viene junto con un formateador de código vba.

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

Control de versiones de XLTools para macros VBA

• control de versiones para hojas Excel y módulos VBA
• Vista previa y cambios de diferencia antes de confirmar una versión
• ideal para el trabajo colaborativo de varios usuarios en el mismo archivo (rastrea quién cambió qué / cuándo / comentarios)
• compare versiones y resalte cambios en el código línea por línea
• adecuado para usuarios que no son expertos en tecnología, o expertos en Excel para el caso
• el historial de versiones se almacena en el repositorio de Git en su propia PC; cualquier versión se puede recuperar fácilmente

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

Es posible que haya intentado usar Excel XML de Microsoft en el contenedor zip (.xlsx y .xslm) para el control de versiones y descubrió que vba estaba almacenado en vbaProject.bin (que no sirve para el control de versiones).

La solución es simple.

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

Cuando repita esto con la próxima versión de la hoja de cálculo, tendrá que asegurarse de que los archivos de la carpeta coincidan exactamente con los del contenedor zip (y no deje ningún archivo eliminado).

También hay un programa llamado Beyond Compare que tiene una buena comparación de archivos Excel. Encontré una captura de pantalla en chino que muestra brevemente esto:

Fuente de imagen original

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

Encontré una solución muy simple para esta pregunta que satisface mis necesidades. Agrego una línea al final de todas mis macros que exporta un *.txtarchivo con el código de macro completo cada vez que se ejecuta. El código:

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

(Se encuentra en los Tutoriales de Tom , que también cubre algunas configuraciones que puede necesitar para que esto funcione).

Como siempre ejecutaré la macro cada vez que esté trabajando en el código, tengo la garantía de que git recogerá los cambios. La única parte molesta es que si necesito pagar una versión anterior, tengo que copiar / pegar manualmente *.txten la hoja de cálculo.

Depende del nivel de integración que desee, he usado Subversion / TortoiseSVN que parece estar bien para un uso simple. También he agregado palabras clave, pero parece haber un riesgo de corrupción de archivos. Hay una opción en Subversion para hacer que las sustituciones de palabras clave tengan una longitud fija y, por lo que entiendo, funcionará si la longitud fija es par pero no impar. En cualquier caso, no obtienes ningún tipo útil de funcionalidad diff, creo que hay productos comerciales que harán 'diff'. Encontré algo que difería en función de convertir cosas a texto 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.), sin embargo, en realidad será el archivo completo (porque es un formato binario), lo que significa que la pregunta "qué cambió" es No es tan fácil de responder.

Todavía puede confiar en los mensajes de registro si las personas los completan, pero también puede probar los nuevos formatos basados ​​en XML de Office 2007 para obtener más visibilidad (aunque aún sería difícil eliminar toneladas de XML, más AFAIK el archivo XML está comprimido en el disco, por lo que necesitaría un enlace previo a la confirmación para descomprimirlo para que el diff de texto funcione correctamente).

Escribí una hoja de cálculo controlada por revisión usando VBA. Está más orientado a los informes de ingeniería en los que tiene varias personas trabajando en una Lista de materiales o Programa y luego, en algún momento, desea crear una revisión de instantánea que muestre adiciones, eliminaciones y actualizaciones de la revisión anterior.

Nota: es un libro habilitado para macros que debe iniciar sesión para descargar desde mi sitio (puede usar OpenID)

Todo el código está desbloqueado.

Hoja de cálculo controlada por Rev

Mi empresa realiza una cantidad considerable de trabajo en la automatización de las soluciones de Microsoft Office, así que escribí un archivo .DLL que exportará el origen de una solución cada vez que se guarde una plantilla. Crea una carpeta llamada Origen como elemento secundario de la carpeta donde se guarda la plantilla, y debajo de Origen crea una carpeta con el mismo nombre que el Proyecto VBA. En la carpeta del proyecto, exporta todo el código fuente para módulos, clases y formularios de usuario. Este arreglo se eligió para facilitar la administración de la fuente de grandes colecciones de plantillas. La DLL puede desbloquear proyectos bloqueados para obtener acceso al proyecto VBA si tiene un archivo de configuración local o un archivo de configuración global disponible. Con esta herramienta en uso, los desarrolladores pueden trabajar en las plantillas a su gusto y usar su herramienta de control de revisiones favorita para administrar su trabajo.