Najlepszy sposób na kontrolę wersji dla MS Excel

Z jakich systemów kontroli wersji korzystałeś w programie MS Excel (2003/2007)? Co byś polecił i dlaczego? Jakie ograniczenia napotkałeś w swoim najlepiej ocenianym systemie kontroli wersji?

Aby spojrzeć na to z perspektywy, oto kilka przypadków użycia:

1. kontrola wersji dla modułów VBA
2. więcej niż jedna osoba pracuje nad arkuszem kalkulacyjnym Excel i może wprowadzać zmiany w tym samym arkuszu, który chce scalić i zintegrować. Ten arkusz może zawierać formuły, dane, wykresy itp
3. użytkownicy nie są zbyt techniczni, a im mniej systemów kontroli wersji jest używanych, tym lepiej
4. Należy wziąć pod uwagę ograniczenie przestrzeni. W idealnym przypadku zapisywane są tylko zmiany przyrostowe, a nie cały arkusz kalkulacyjny programu Excel.

Właśnie skonfigurowałem arkusz kalkulacyjny, który używa Bazaar, z ręcznym zameldowaniem / wymeldowaniem przez TortiseBZR. Biorąc pod uwagę, że temat pomógł mi z częścią oszczędzania, chciałem zamieścić tutaj moje rozwiązanie.

Rozwiązaniem dla mnie było utworzenie arkusza kalkulacyjnego, który eksportuje wszystkie moduły przy zapisywaniu i usuwa i ponownie importuje moduły przy otwieraniu. Tak, może to być potencjalnie niebezpieczne w przypadku konwersji istniejących arkuszy kalkulacyjnych.

To pozwala mi edytować makra w modułach za pośrednictwem Emacsa (tak, emacs) lub natywnie w Excelu i zatwierdzać moje repozytorium BZR po dużych zmianach. Ponieważ wszystkie moduły są plikami tekstowymi, standardowe polecenia w stylu diff w BZR działają dla moich źródeł z wyjątkiem samego pliku Excel.

Skonfigurowałem katalog dla mojego repozytorium BZR, X: \ Data \ MySheet. W repozytorium znajdują się MySheet.xls i jeden plik .vba dla każdego z moich modułów (np. Module1Macros). W moim arkuszu kalkulacyjnym dodałem jeden moduł, który jest zwolniony z cyklu eksportu / importu o nazwie „VersionControl”. Każdy moduł, który ma zostać wyeksportowany i ponownie zaimportowany, musi kończyć się napisem „Makra”.

Zawartość modułu „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

Następnie musimy ustawić punkty zaczepienia zdarzeń dla otwierania / zapisywania, aby uruchomić te makra. W przeglądarce kodu kliknij prawym przyciskiem myszy „ThisWorkbook” i wybierz „View Code”. Może być konieczne rozwinięcie pola wyboru u góry okna kodu, aby zmienić widok z widoku „(Ogólne)” na „Skoroszyt”.

Zawartość widoku „Skoroszyt”:

Private Sub Workbook_Open()

ImportCodeModules

End Sub

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

SaveCodeModules

End Sub

W ciągu następnych kilku tygodni będę dostosowywać się do tego przepływu pracy i opublikuję, jeśli mam jakiekolwiek problemy.

Dziękujemy za udostępnienie kodu VBComponent!

TortoiseSVN to zadziwiająco dobry klient Windows dla systemu kontroli wersji Subversion. Jedną z funkcji, którą właśnie odkryłem, jest to, że kiedy klikniesz, aby uzyskać różnicę między wersjami pliku Excel, otworzy obie wersje w programie Excel i podświetli (na czerwono) komórki, które zostały zmienione. Odbywa się to za pomocą magii skryptu VBS, opisanego tutaj .

Może ci się to przydać, nawet jeśli NIE używasz TortoiseSVN.

Pozwólcie, że podsumuję, co chcielibyście kontrolować wersji i dlaczego:

1. Co:

   • Kod (VBA)
   • Arkusze kalkulacyjne (wzory)
   • Arkusze kalkulacyjne (wartości)
   • Wykresy
   • ...

2. Czemu:

   • Dziennik kontroli
   • Współpraca
   • Porównanie wersji („różnica”)
   • Łączenie

Jak napisali tutaj inni, istnieje kilka rozwiązań oprócz istniejących systemów kontroli wersji, takich jak:

• Git
• Bystry
• Obalenie
• Bazar

Jeśli Twoim jedynym zmartwieniem jest kod VBA w skoroszytach, to podejście, które proponuje Demosthenex, lub VbaGit ( https://github.com/brucemcpherson/VbaGit ) działa bardzo dobrze i jest stosunkowo proste do wdrożenia. Zaletą jest to, że możesz polegać na sprawdzonych systemach kontroli wersji i wybrać taki zgodnie ze swoimi potrzebami (zajrzyj na https://help.github.com/articles/what-are-the-differences-between-svn-and -git / dla krótkiego porównania między Git i Subversion).

Jeśli martwisz się nie tylko o kod, ale także o dane w arkuszach (wartości „zakodowane na stałe” i wyniki formuł), możesz zastosować podobną strategię: Serializuj zawartość arkuszy do jakiegoś formatu tekstowego (za pośrednictwem Range.Value) i użyj istniejącego systemu kontroli wersji. Oto bardzo dobry wpis na blogu na ten temat: https://wiki.ucl.ac.uk/display/~ucftpw2/2013/10/18/Using+git+for+version+control+of+spreadsheet+models+-+part + 1 + z + 3

Jednak porównanie arkuszy kalkulacyjnych jest nietrywialnym problemem algorytmicznym. Istnieje kilka narzędzi, takich jak porównanie arkuszy kalkulacyjnych firmy Microsoft ( https://support.office.com/en-us/article/Overview-of-Spreadsheet-Compare-13fafa61-62aa-451b-8674-242ce5f2c986 ), Exceldiff ( http://exceldiff.arstdesign.com/ ) i DiffEngineX ( https://www.floreailabilityoft.com/compare-excel-workbooks-differences.html ). Ale kolejnym wyzwaniem jest zintegrowanie tego porównania z systemem kontroli wersji, takim jak Git.

Wreszcie, musisz zdecydować się na przepływ pracy, który odpowiada Twoim potrzebom. Aby zapoznać się z prostym, dostosowanym przepływem pracy Git for Excel, zajrzyj na https://www.xltrail.com/blog/git-workflow-for-excel .

Zależy to od tego, czy mówisz o danych, czy o kodzie zawartym w arkuszu kalkulacyjnym. Chociaż mam silną niechęć do Visual Sourcesafe firmy Microsoft i normalnie nie polecałbym go, łatwo integruje się zarówno z Access, jak i Excelem, i zapewnia kontrolę źródła modułów.

[W rzeczywistości integracja z Access obejmuje zapytania, raporty i moduły jako pojedyncze obiekty, które można wersjonować]

Link MSDN jest tutaj .

Nie znam narzędzia, które robi to dobrze, ale widziałem wiele własnych rozwiązań. Ich wspólnym wątkiem jest minimalizacja danych binarnych pod kontrolą wersji i maksymalizacja danych tekstowych w celu wykorzystania możliwości konwencjonalnych systemów scc. Aby to zrobić:

• Traktuj skoroszyt jak każdą inną aplikację. Oddzielna logika, konfiguracja i dane.
• Oddziel kod ze skoroszytu.
• Zbuduj interfejs użytkownika programowo.
• Napisz skrypt kompilacji, aby zrekonstruować skoroszyt.

Praca nad dziełem @Demosthenex, nieocenione komentarze @Tmdean i @Jon Crowell! (Daj im +1)

Zapisuję pliki modułów w git \ dir obok lokalizacji skoroszytu. Zmień to według własnych upodobań.

NIE spowoduje to śledzenia zmian w kodzie skoroszytu. Więc to do Ciebie należy ich synchronizacja.

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

A następnie w module skoroszyt:

Private Sub Workbook_Open()

    ImportCodeModules

End Sub

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

    SaveCodeModules

End Sub

Idąc o krok dalej z odpowiedzią @Demosthenex, jeśli chcesz również śledzić kod w swoich obiektach Microsoft Excel i formularzach użytkownika, musisz trochę skomplikować.

Najpierw zmieniłem SaveCodeModules()funkcję, aby uwzględnić różne typy kodu, które planuję wyeksportować:

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

Formularze użytkownika można eksportować i importować, podobnie jak kod VBA. Jedyną różnicą jest to, że po wyeksportowaniu formularza zostaną utworzone dwa pliki (otrzymasz .frmi .frxplik dla każdego UserForm). Jeden z nich zawiera napisane przez Ciebie oprogramowanie, a drugi to plik binarny, który (jestem prawie pewien) definiuje układ formularza.

Microsoft Excel Objects (meos) (w rozumieniu Sheet1, Sheet2, ThisWorkbooketc) mogą być eksportowane w postaci .clspliku. Jednak jeśli chcesz odzyskać ten kod w skoroszycie, jeśli spróbujesz zaimportować go w taki sam sposób, jak w przypadku modułu VBA, pojawi się błąd, jeśli ten arkusz już istnieje w skoroszycie.

Aby obejść ten problem, postanowiłem nie próbować importować pliku .cls do programu Excel, ale .clszamiast tego wczytać plik do programu Excel jako ciąg znaków, a następnie wkleić ten ciąg do pustego MEO. Oto moje 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

Jeśli jesteś zdezorientowany danymi dirwejściowymi do obu tych funkcji, jest to tylko repozytorium kodu! Tak więc nazwałbyś te funkcje:

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

Używam git , a dziś przeportowałem to (git-xlsx-textconv) do Pythona, ponieważ mój projekt jest oparty na kodzie Pythona i współdziała z plikami Excel. Działa to przynajmniej z plikami .xlsx , ale myślę, że będzie działać również dla plików .xls . Oto link do github. Napisałem dwie wersje, jedną z każdym wierszem w osobnym wierszu i drugą, w której każda komórka znajduje się w osobnym wierszu (ta ostatnia została napisana, ponieważ git diff nie lubi domyślnie zawijać długich linii, przynajmniej tutaj w systemie Windows).

To jest mój plik .gitconfig (umożliwia to umieszczenie skryptu Different w repozytorium mojego projektu):

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

jeśli chcesz, aby skrypt był dostępny dla wielu różnych repozytoriów, użyj czegoś takiego:

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

mój plik .gitattributes :

*.xlsx diff=xlsx

Jedną z rzeczy, które możesz zrobić, to mieć następujący fragment kodu w swoim skoroszycie:

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

Znalazłem ten fragment w Internecie.

Później możesz użyć Subversion do utrzymania kontroli wersji. Na przykład używając interfejsu wiersza poleceń Subversion z poleceniem „powłoka” w VBA. To wystarczy. Myślę nawet o zrobieniu tego samodzielnie :)

Chciałbym polecić świetne narzędzie open source o nazwie Rubberduck, które ma wbudowaną kontrolę wersji kodu VBA. Wypróbuj!

Jeśli szukasz miejsca w biurze ze zwykłymi użytkownikami, którzy nie mają wiedzy technicznej, Sharepoint jest realną alternatywą. Możesz skonfigurować foldery dokumentów z włączoną kontrolą wersji oraz checkins i checkouts. Sprawia, że ​​jest bardziej przyjazny dla zwykłych użytkowników biurowych.

w odpowiedzi na odpowiedź mattlanta - sharepoint będzie działał dobrze jako kontrola wersji tylko wtedy, gdy funkcja kontroli wersji jest włączona w bibliotece dokumentów. Ponadto należy pamiętać, że każdy kod, który wywołuje inne pliki za pomocą ścieżek względnych, nie zadziała. i wreszcie wszelkie łącza do plików zewnętrznych zostaną zerwane, gdy plik zostanie zapisany w programie SharePoint.

Użyj dowolnego ze standardowych narzędzi do kontroli wersji, takich jak SVN lub CVS. Ograniczenia zależałyby od celu. Oprócz niewielkiego zwiększenia rozmiaru repozytorium nie napotkałem żadnych problemów

Powinieneś wypróbować DiffEngineX. Można go wywołać programowo, a także z wiersza poleceń, pobierając argumenty wiersza poleceń. Porównuje nie tylko komórki arkuszy kalkulacyjnych programu Excel, ale także makra języka Visual Basic osadzone w skoroszytach. Porównuje również nazwy i komentarze zdefiniowane w programie Excel, których wiele bezpłatnych narzędzi pomija. Można go pobrać z

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

Jestem pewien, że twój system kontroli wersji ma opcję lub pole, dzięki czemu możesz automatycznie wywoływać DiffEngineX z oryginalnymi i zmodyfikowanymi skoroszytami programu Excel.

Też się temu przyjrzałem. Wygląda na to, że najnowszy Team Foundation Server 2010 może mieć dodatek programu Excel.

Oto wskazówka:

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

Po wyszukaniu grup wiekowych i wypróbowaniu wielu różnych narzędzi, znalazłem odpowiedź na problem z kontrolą wersji vba tutaj: https://stackoverflow.com/a/25984759/2780179

To prosty dodatek do programu Excel, którego kod można znaleźć tutaj

Po zaimportowaniu nie ma zduplikowanych modułów. Eksportuje kod automatycznie, gdy tylko zapiszesz skoroszyt, bez modyfikowania istniejących skoroszytów . Jest dołączany do programu formatującego kod VBA.

W rzeczywistości istnieje tylko kilka rozwiązań do śledzenia i porównywania zmian w kodzie makr - większość z nich została już tutaj wymieniona. Przeglądałem sieć i natknąłem się na to nowe narzędzie, o którym warto wspomnieć:

Kontrola wersji XLTools dla makr VBA

• kontrola wersji dla arkuszy Excel i modułów VBA
• podgląd i różnice zmian przed zatwierdzeniem wersji
• świetne do wspólnej pracy kilku użytkowników nad tym samym plikiem (śledzenie, kto zmienił co / kiedy / komentarze)
• porównaj wersje i zaznacz zmiany w kodzie wiersz po wierszu
• odpowiedni dla użytkowników, którzy nie znają się na technologii lub w Excelu
• historia wersji jest przechowywana w repozytorium Git na Twoim komputerze - każdą wersję można łatwo odzyskać

Wersje kodu VBA obok siebie, zmiany są wizualizowane

Być może próbowałeś użyć Microsoft Excel XML w kontenerze zip (.xlsx i .xslm) do kontroli wersji i odkryłeś, że vba jest przechowywany w vbaProject.bin (który jest bezużyteczny do kontroli wersji).

Rozwiązanie jest proste.

1. Otwórz plik Excela za pomocą LibreOffice Calc
2. W LibreOffice Calc
   1. Plik
   2. Zapisz jako
   3. Zapisz jako typ: Arkusz kalkulacyjny ODF (ods)
3. Zamknij LibreOffice Calc
4. zmień rozszerzenie nowego pliku z .ods na .zip
5. utwórz folder dla arkusza kalkulacyjnego w obszarze zarządzanym przez GIT
6. rozpakuj zip do swojego folderu GIT
7. zobowiązać się do GIT

Gdy powtórzysz to z następną wersją arkusza kalkulacyjnego, będziesz musiał upewnić się, że pliki folderu są dokładnie zgodne z tymi w kontenerze zip (i nie zostawiaj żadnych usuniętych plików w tyle).

Istnieje również program o nazwie Beyond Compare, który ma całkiem niezłe porównanie plików Excel. Znalazłem zrzut ekranu w języku chińskim, który krótko pokazuje to:

Oryginalne źródło obrazu

Na ich stronie jest 30-dniowy okres próbny

Znalazłem bardzo proste rozwiązanie tego pytania, które odpowiada moim potrzebom. Dodaję jedną linię na dole wszystkich moich makr, która eksportuje *.txtplik z całym kodem makra za każdym razem, gdy jest uruchamiany. Kod:

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

(Znalezione w samouczkach Toma , które obejmują również niektóre konfiguracje, których możesz potrzebować, aby to działało).

Ponieważ zawsze będę uruchamiał makro, gdy pracuję nad kodem, mam gwarancję, że git wykryje zmiany. Jedyną irytującą częścią jest to, że jeśli muszę pobrać wcześniejszą wersję, muszę ręcznie skopiować / wkleić z *.txtarkusza do arkusza kalkulacyjnego.

To zależy od tego, jaki poziom integracji chcesz, użyłem Subversion / TortoiseSVN, który wydaje się być w porządku do prostego użycia. Dodałem również słowa kluczowe, ale wydaje się, że istnieje ryzyko uszkodzenia plików. W Subversion istnieje opcja, aby podstawiać słowa kluczowe o stałej długości i, o ile rozumiem, będzie działać, jeśli stała długość jest parzysta, ale nie dziwna. W każdym razie nie dostaniesz żadnej użytecznej funkcji porównywania, myślę, że są produkty komercyjne, które zrobią 'diff'. Znalazłem coś, co robiło różnicę, polegające na konwersji rzeczy do zwykłego tekstu i porównaniu tego, ale nie było to zbyt przyjemne.

Powinien działać z większością VCS (w zależności od innych kryteriów możesz wybrać SVN, CVS, Darcs, TFS, itp.), Jednak w rzeczywistości będzie to kompletny plik (ponieważ jest to format binarny), co oznacza, że ​​pytanie „co się zmieniło” brzmi nie tak łatwo odpowiedzieć.

Nadal możesz polegać na komunikatach dziennika, jeśli ludzie je wypełnią, ale możesz również wypróbować nowe formaty oparte na XML z pakietu Office 2007, aby uzyskać większą widoczność (chociaż nadal byłoby trudno przefiltrować tony XML, a także AFAIK plik XML jest spakowany na dysku, więc do jego rozpakowania potrzebny byłby punkt zaczepienia przed zatwierdzeniem, aby różnica tekstowa działała poprawnie).

Napisałem arkusz kalkulacyjny z kontrolą wersji przy użyciu VBA. Jest bardziej nastawiony na raporty inżynieryjne, w których wiele osób pracuje nad wykazem materiałów lub harmonogramem, a następnie w pewnym momencie chcesz utworzyć wersję migawki, która pokazuje dodania, usunięcia i aktualizacje z poprzedniej wersji.

Uwaga: jest to skoroszyt z obsługą makr, który musisz zalogować się, aby pobrać z mojej witryny (możesz użyć OpenID)

Cały kod jest odblokowany.

Rev Controlled Spreadsheet

Moja firma wykonuje znaczną pracę w zakresie automatyzacji rozwiązań Microsoft Office, dlatego napisałem .DLL, który będzie eksportował źródło rozwiązania za każdym razem, gdy zapisywany jest szablon. Tworzy folder o nazwie Source jako element podrzędny folderu, w którym zapisano szablon, a pod źródłem tworzy folder o tej samej nazwie, co projekt VBA. W folderze projektu eksportuje cały kod źródłowy modułów, klas i formularzy użytkownika. To ustawienie zostało wybrane, aby ułatwić zarządzanie źródłem dużych zbiorów szablonów. Biblioteka DLL może odblokować zablokowane projekty, aby uzyskać dostęp do projektu VBA, jeśli masz lokalny plik konfiguracyjny lub globalny plik konfiguracyjny. Dzięki temu narzędziu programiści mogą pracować nad szablonami według ich treści i używać swojego ulubionego narzędzia do kontroli wersji do zarządzania swoją pracą.