Melhor maneira de fazer o Controle de Versão para MS Excel

Quais sistemas de controle de versão você usou com o MS Excel (2003/2007)? O que você recomendaria e por quê? Quais limitações você encontrou no seu sistema de controle de versão com melhor classificação?

Para colocar isso em perspectiva, aqui estão alguns casos de uso:

1. controle de versão para módulos VBA
2. mais de uma pessoa está trabalhando em uma planilha do Excel e elas podem estar fazendo alterações na mesma planilha, que desejam mesclar e integrar. Esta planilha pode ter fórmulas, dados, gráficos etc.
3. os usuários não são muito técnicos e quanto menos sistemas de controle de versão forem utilizados, melhor
4. A restrição de espaço é uma consideração. Idealmente, apenas alterações incrementais são salvas, em vez de toda a planilha do Excel.

Acabei de configurar uma planilha que usa o Bazaar, com entrada / saída manual via TortiseBZR. Como o tópico me ajudou com a parte de salvamento, eu queria postar minha solução aqui.

A solução para mim foi criar uma planilha que exporta todos os módulos ao salvar e remove e reimporta os módulos ao abrir. Sim, isso pode ser potencialmente perigoso para a conversão de planilhas existentes.

Isso me permite editar as macros nos módulos via Emacs (sim, emacs) ou nativamente no Excel e confirmar meu repositório BZR após grandes alterações. Como todos os módulos são arquivos de texto, os comandos padrão do estilo diff no BZR funcionam para minhas fontes, exceto o próprio arquivo do Excel.

Eu configurei um diretório para o meu repositório BZR, X: \ Data \ MySheet. No repositório estão MySheet.xls e um arquivo .vba para cada um dos meus módulos (por exemplo: Module1Macros). Na minha planilha, adicionei um módulo isento do ciclo de exportação / importação chamado "VersionControl". Cada módulo a ser exportado e reimportado deve terminar em "Macros".

Conteúdo do 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

Em seguida, temos que configurar ganchos de eventos para abrir / salvar para executar essas macros. No visualizador de código, clique com o botão direito do mouse em "ThisWorkbook" e selecione "View Code". Pode ser necessário puxar a caixa de seleção na parte superior da janela de código para mudar da exibição "(Geral)" para a exibição "Pasta de trabalho".

Conteúdo da exibição "Pasta de trabalho":

Private Sub Workbook_Open()

ImportCodeModules

End Sub

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

SaveCodeModules

End Sub

Entrarei nesse fluxo de trabalho nas próximas semanas e postarei se tiver algum problema.

Obrigado por compartilhar o código VBComponent!

O TortoiseSVN é um cliente Windows surpreendentemente bom para o sistema de controle de versão do Subversion. Um recurso que acabei de descobrir é que, quando você clica para obter uma diferença entre as versões de um arquivo do Excel, ele abre as duas versões no Excel e destaca (em vermelho) as células que foram alteradas. Isso é feito através da mágica de um script vbs, descrito aqui .

Você pode achar isso útil mesmo que NÃO esteja usando o TortoiseSVN.

Deixe-me resumir o que você gostaria de controlar a versão e por que:

1. O que:

   • Código (VBA)
   • Planilhas (Fórmulas)
   • Planilhas (valores)
   • Gráficos
   • ...

2. Por quê:

   • Log de auditoria
   • Colaboração
   • Comparação de versões ("diffing")
   • Mesclando

Como outros já postaram aqui, existem algumas soluções sobre os sistemas de controle de versão existentes, como:

• Git
• Mercurial
• Subversão
• Bazar

Se sua única preocupação é o código VBA em suas pastas de trabalho, a abordagem que o Demosthenex acima propõe ou o VbaGit ( https://github.com/brucemcpherson/VbaGit ) funcionam muito bem e são relativamente simples de implementar. As vantagens são que você pode confiar em sistemas de controle de versão comprovados e escolher um de acordo com suas necessidades (consulte https://help.github.com/articles/what-are-the-differences-between-svn-and -git / para uma breve comparação entre Git e Subversion).

Se você não apenas se preocupa com o código, mas também com os dados em suas planilhas (valores "codificados" e resultados da fórmula)), pode usar uma estratégia semelhante para isso: serialize o conteúdo das planilhas em algum formato de texto (via Range.Value) e use um sistema de controle de versão existente. Aqui está uma publicação muito boa no blog sobre isso: https://wiki.ucl.ac.uk/display/~ucftpw2/2013/10/18/Using+git+for+version+control+of+spreadsheet+models+-+part + 1 + de + 3

No entanto, a comparação de planilhas é um problema algorítmico não trivial. Existem algumas ferramentas, como a Spreadsheet Compare da Microsoft ( https://support.office.com/en-us/article/Overview-of-Spreadsheet-Compare-13fafa61-62aa-451b-8674-242ce5f2c986 ), Exceldiff ( http://exceldiff.arstdesign.com/ ) e DiffEngineX ( https://www.florencesoft.com/compare-excel-workbooks-differences.html ). Mas é outro desafio integrar essas comparações a um sistema de controle de versão como o Git.

Por fim, você deve optar por um fluxo de trabalho que atenda às suas necessidades. Para um fluxo de trabalho simples e personalizado do Git for Excel, consulte https://www.xltrail.com/blog/git-workflow-for-excel .

Depende se você está falando de dados ou do código contido em uma planilha. Embora eu tenha uma forte aversão ao Visual Sourcesafe da Microsoft e normalmente não o recomendaria, ele se integra facilmente ao Access e ao Excel e fornece controle de origem dos módulos.

[De fato, a integração com o Access inclui consultas, relatórios e módulos como objetos individuais que podem ser versionados]

O link do MSDN está aqui .

Não conheço uma ferramenta que faça isso bem, mas já vi várias soluções caseiras. O objetivo comum é minimizar os dados binários sob controle de versão e maximizar os dados textuais para alavancar o poder dos sistemas scc convencionais. Para fazer isso:

• Trate a pasta de trabalho como qualquer outro aplicativo. Lógica, configuração e dados separados.
• Separe o código da pasta de trabalho.
• Crie a interface do usuário programaticamente.
• Escreva um script de construção para reconstruir a pasta de trabalho.

Trabalhando no trabalho de @Demosthenex, comentários inestimáveis ​​de @Tmdean e @Jon Crowell! (Marque com +1)

Eu salvo os arquivos do módulo no git \ dir ao lado da localização da pasta de trabalho. Mude isso ao seu gosto.

Isso NÃO rastreará alterações no código da pasta de trabalho. Portanto, cabe a você sincronizá-los.

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

E então no módulo Pasta de Trabalho:

Private Sub Workbook_Open()

    ImportCodeModules

End Sub

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

    SaveCodeModules

End Sub

Levando a resposta do @Demosthenex um passo adiante, se você também deseja acompanhar o código nos Objetos e Formulários de Usuário do Microsoft Excel, você deve ser um pouco complicado.

Primeiro, alterei minha SaveCodeModules()função para considerar os diferentes tipos de código que pretendo 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

Os UserForms podem ser exportados e importados como código VBA. A única diferença é que dois arquivos serão criados quando um formulário for exportado (você receberá um .frme um.frx arquivo para cada formulário de usuário). Um deles contém o software que você escreveu e o outro é um arquivo binário que (tenho certeza) define o layout do formulário.

Microsoft Excel Objects (MEOs) (o que significa Sheet1, Sheet2, ThisWorkbooketc) pode ser exportado como um .clsarquivo. No entanto, quando você deseja recuperar esse código em sua pasta de trabalho, se tentar importá-lo da mesma maneira que faria com um módulo VBA, ocorrerá um erro se essa planilha já existir na pasta de trabalho.

Para contornar esse problema, decidi não tentar importar o arquivo .cls para o Excel, mas, .clsem vez disso, ler o arquivo no excel como uma sequência e colar essa sequência no MEO vazio. Aqui está o meu 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

Caso você esteja confuso com a direntrada de ambas as funções, esse é apenas o seu repositório de código! Então, você chamaria essas funções como:

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

Eu uso o git e hoje eu o transformei (git-xlsx-textconv) no Python, pois meu projeto é baseado no código Python e interage com os arquivos do Excel. Isso funciona para pelo menos arquivos .xlsx , mas acho que também funcionará para .xls . Aqui está o link do github. Eu escrevi duas versões, uma com cada linha em sua própria linha e outra em que cada célula está em sua própria linha (a última foi escrita porque o git diff não gosta de quebrar linhas longas por padrão, pelo menos aqui no Windows).

Este é o meu arquivo .gitconfig (permite que o script diferente resida no repositório do meu projeto):

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

se você deseja que o script esteja disponível para vários repositórios diferentes, use algo como isto:

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

meu arquivo .gitattributes :

*.xlsx diff=xlsx

Uma coisa que você pode fazer é ter o seguinte trecho na sua pasta de trabalho:

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

Encontrei esse trecho na Internet.

Depois, você pode usar o Subversion para manter o controle de versão. Por exemplo, usando a interface da linha de comandos do Subversion com o comando 'shell' no VBA. Isso faria isso. Estou pensando em fazer isso sozinho :)

Eu gostaria de recomendar uma ótima ferramenta de código aberto chamada Rubberduck que possui controle de versão do código VBA embutido. Experimente!

Se você estiver procurando um ambiente de escritório com usuários não técnicos regulares, o Sharepoint é uma alternativa viável. Você pode configurar pastas de documentos com o controle de versão ativado e check-ins e check-out. Torna mais amigável para usuários comuns de escritório.

em resposta à resposta do mattlant - o sharepoint funcionará bem como um controle de versão somente se o recurso de controle de versão estiver ativado na biblioteca de documentos. Além disso, esteja ciente de que qualquer código que chame outros arquivos por caminhos relativos não funcionará. e, finalmente, qualquer link para arquivos externos será interrompido quando um arquivo for salvo no sharepoint.

Use qualquer uma das ferramentas de controle de versão padrão, como SVN ou CVS. Limitações dependeriam de qual é o objetivo. Além de um pequeno aumento no tamanho do repositório, eu não enfrentei nenhum problema

Você deve tentar o DiffEngineX. Pode ser chamado programaticamente e também a partir da linha de comando, recebendo argumentos da linha de comando. Ele não apenas compara as células das planilhas do Excel, mas também as macros do Visual Basic incorporadas nas pastas de trabalho. Também compara nomes e comentários definidos pelo Excel, que muitas ferramentas freeware perdem. Pode ser baixado em

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

Tenho certeza de que seu sistema de controle de versão possui uma opção ou caixa para que você possa ligar automaticamente para o DiffEngineX com suas pastas de trabalho originais e modificadas do Excel.

Também estive investigando isso. Parece que o Team Foundation Server 2010 mais recente pode ter um suplemento do Excel.

Aqui está uma pista:

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

Depois de pesquisar por idades e experimentar muitas ferramentas diferentes, encontrei minha resposta para o problema de controle de versão do vba aqui: https://stackoverflow.com/a/25984759/2780179

É um suplemento simples para o Excel, para o qual o código pode ser encontrado aqui

Não há módulos duplicados após a importação. Ele exporta seu código automaticamente, assim que você salva sua pasta de trabalho, sem modificar nenhuma pasta de trabalho existente . Ele vem junto com um formatador de código vba.

Na verdade, existem apenas algumas soluções para rastrear e comparar alterações no código de macro - a maioria delas já foi mencionada aqui. Estive navegando na web e me deparei com esta nova ferramenta que vale a pena mencionar:

Controle de versão XLTools para macros VBA

• controle de versão para planilhas do Excel e módulos VBA
• visualizar e alterar alterações antes de confirmar uma versão
• ótimo para trabalhos colaborativos de vários usuários no mesmo arquivo (acompanhar quem mudou o que / quando / comentários)
• comparar versões e destacar alterações no código linha por linha
• adequado para usuários que não possuem conhecimento de tecnologia ou conhecimento sobre Excel,
• o histórico de versões é armazenado no repositório Git no seu próprio PC - qualquer versão pode ser facilmente recuperada

Versões de código VBA lado a lado, as alterações são visualizadas

Você pode ter tentado usar o XML do Excel da Microsoft no contêiner zip (.xlsx e .xslm) para controle de versão e descobriu que o vba estava armazenado em vbaProject.bin (que é inútil para o controle de versão).

A solução é simples.

1. Abra o arquivo excel com o LibreOffice Calc
2. No LibreOffice Calc
   1. Arquivo
   2. Salvar como
   3. Salvar como tipo: Planilha ODF (.ods)
3. Fechar o LibreOffice Calc
4. renomeie a extensão do novo arquivo de .ods para .zip
5. crie uma pasta para a planilha em uma área mantida pelo GIT
6. extrair o zip para a pasta GIT
7. comprometer-se com o GIT

Quando você repetir isso com a próxima versão da planilha, precisará garantir que os arquivos da pasta correspondam exatamente aos do contêiner zip (e não deixe nenhum arquivo excluído para trás).

Há também um programa chamado Beyond Compare que possui uma comparação muito boa de arquivos do Excel. Encontrei uma captura de tela em chinês que mostra brevemente isso:

Fonte da imagem original

Há uma avaliação de 30 dias na página deles

Encontrei uma solução muito simples para essa pergunta que atende às minhas necessidades. Eu adiciono uma linha na parte inferior de todas as minhas macros que exporta um *.txtarquivo com o código de macro inteiro toda vez que é executado. O código:

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

(Encontrado nos Tutoriais de Tom , que também abordam algumas configurações necessárias para que isso funcione.)

Como eu sempre executarei a macro sempre que estiver trabalhando no código, tenho certeza de que o git receberá as alterações. A única parte irritante é que, se eu precisar fazer o check-out de uma versão anterior, tenho que copiar / colar manualmente *.txtda planilha.

Depende do nível de integração desejado, usei o Subversion / TortoiseSVN, o que parece bom para o uso simples. Também adicionei palavras-chave, mas parece haver um risco de corrupção de arquivos. Existe uma opção no Subversion para fazer com que as substituições de palavras-chave sejam de comprimento fixo e, pelo que entendi, funcionará se o comprimento fixo for par, mas não for ímpar. De qualquer forma, você não obtém nenhum tipo útil de funcionalidade diff, acho que existem produtos comerciais que farão 'diff'. Eu encontrei algo que difere baseado na conversão de coisas em texto sem formatação e na comparação, mas não foi muito bom.

Ele deve funcionar com a maioria dos VCS (dependendo de outros critérios, você pode escolher SVN, CVS, Darcs, TFS, etc); no entanto, na verdade, ele será o arquivo completo (por ser um formato binário), o que significa que a pergunta "o que mudou" é não é tão fácil de responder.

Você ainda pode confiar nas mensagens de log se as pessoas as concluírem, mas também pode experimentar os novos formatos baseados em XML do Office 2007 para obter mais visibilidade (embora ainda seja difícil extrair toneladas de XML, além do arquivo AFAIK XML) está compactado no disco, então você precisaria de um gancho de pré-confirmação para descompactá-lo para que o diff de texto funcione corretamente).

Escrevi uma planilha controlada por revisão usando VBA. É mais voltado para relatórios de engenharia, nos quais você tem várias pessoas trabalhando em uma Lista de materiais ou Cronograma e, em algum momento, deseja criar uma revisão de instantâneo que mostre adições, exclusão e atualizações da rev. Anterior.

Nota: é uma pasta de trabalho habilitada para macro que você precisa fazer login para baixar do meu site (você pode usar o OpenID)

Todo o código está desbloqueado.

Planilha Controlada por Rev

Minha empresa faz uma quantidade considerável de trabalho na automação das soluções do Microsoft Office, então escrevi um .DLL que exportará a fonte de uma solução sempre que um modelo for salvo. Ele cria uma pasta chamada Origem como filho da pasta em que o modelo é salvo e, abaixo da Fonte, cria uma pasta com o mesmo nome que o Projeto VBA. Na pasta do projeto, ele exporta todo o código-fonte para módulos, classes e formulários do usuário. Esse arranjo foi escolhido para facilitar o gerenciamento da fonte de grandes coleções de modelos. A DLL pode desbloquear projetos bloqueados para obter acesso ao projeto VBA se você tiver um arquivo de configuração local ou um arquivo de configuração global disponível. Com essa ferramenta em uso, os desenvolvedores podem trabalhar em modelos para o conteúdo ideal e usar sua ferramenta de controle de revisão favorita para gerenciar seu trabalho.