Update module_base.py

.github/workflows/python-package.yml

@@ -15,7 +15,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.8", "3.9", "3.10"]
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
 
     steps:
     - uses: actions/checkout@v3
@@ -26,12 +26,9 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        python -m pip install flake8 pytest
-        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
-        if [ -f requirements_dev.txt ]; then pip install -r requirements_dev.txt; fi
-        pip install git+https://github.com/Beakerboy/MS-CFB@dev
-        pip install git+https://github.com/Beakerboy/MS-Pcode-Assembler@dev
-        pip install -e .
+        pip install git+https://github.com/Beakerboy/MS-CFB
+        pip install git+https://github.com/Beakerboy/MS-Pcode-Assembler
+        pip install -e .[tests]
     - name: Lint with flake8
       run: |
         # stop the build if there are Python syntax errors or undefined names
@@ -42,15 +39,16 @@ jobs:
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       run: |
-        pytest --cov=vbaProjectCompiler
+        pytest --cov=src
         coveralls --service=github
+        ls -al
 
   flake8:
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.10"]
+        python-version: ["3.14"]
     steps:
     - uses: actions/checkout@v3
     - name: Set up Python ${{ matrix.python-version }}

README.md

@@ -1,56 +1,39 @@
-[![Coverage Status](https://coveralls.io/repos/github/Beakerboy/vbaProject-Compiler/badge.svg?branch=main)](https://coveralls.io/github/Beakerboy/vbaProject-Compiler?branch=main)
+[![Coverage Status](https://coveralls.io/repos/github/Beakerboy/MS-OVBA/badge.svg?branch=main)](https://coveralls.io/github/Beakerboy/MS-OVBA?branch=main)
 # vbaProject-Compiler
 Create a vbaProject.bin file from VBA source files.
 
 
-## VBAProject Class
+## Command Line Interface
+Eventually it will be possible to use the CLI to create a vbaProject.bin file from source files and an optional configuration file.
 
-The vbaProject class contains all the data and metadata that will be used to create the OLE container.
+## VBAProject Class
+The vbaProject class contains all the data and metadata that is used to create the OLE container. It can use this data to create several files, then compress and combine them into an OLE container
 
 ```python
-from vbaProjectCompiler.vbaProject import VbaProject
-from vbaProjectCompiler.ole_file import OleFile
+from ms_ovba.vbaProject import VbaProject
+from ms_cfb.ole_file import OleFile
 
 
 project = VbaProject()
 thisWorkbook = DocModule("ThisWorkbook")
 thisWorkbook.addFile(path)
 project.addModule(thisWorkbook)
 
-ole_file = OleFile(project)
-ole_file.writeFile(".")
+ProjectOleFile.write_file(project)
 ```
 
-The VbaProject class has many layers of customization available. Forexample a librry referenece can be added to the project.
+The VbaProject class has many layers of customization available. For example a library reference can be added to the project.
 
 ```python
 codePage = 0x04E4
 codePageName = "cp" + str(codePage)
-libidRef = LibidReference(
-    "windows",
+libidRef = ReferenceRecord(codePageName, LibidReference(
     "{00020430-0000-0000-C000-000000000046}",
     "2.0",
     "0",
     "C:\\Windows\\System32\\stdole2.tlb",
     "OLE Automation"
-)
-oleReference = ReferenceRecord(codePageName, "stdole", libidRef)
+))
+oleReference = Reference(codePageName, libidRef, "stdole")
 project.addReference(oleReference)
 ```
-
-## oleFile Class
-
-Users should not have to interact with the oleFile class. It's job is to extract the data from the vbaProject and turn it into a valid file. This includes deciding which data stream appears where, and applying different views to the models to save the data in the correct formats.
-
-The oleFIle has two parts, a header and a FAT Sector Chain. This FAT chain stores multiple streams of data:
-* Fat Chain Stream
-* Directory Stream
-* Minifat Chain Stream
-* Minifat Data Stream
-* Fat Data Stream
-
-These are all different views of data from the following Models
-
-* fatChain
-* minifatChain
-* directoryStream

pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools>=61.0"]
 build-backend = "setuptools.build_meta"
 
 [project]
-name = "vba_project_compiler"
+name = "vbaproject_compiler"
 version = "0.0.1"
 authors = [
   { name="Kevin Nowaczyk", email="beakerboy99@yahoo.com" },
@@ -16,7 +16,19 @@ classifiers = [
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
 ]
-
+dependencies = [
+    'ms_ovba_compression',
+    'ms_ovba_crypto'
+]
+[project.optional-dependencies]
+tests = [
+  'pytest',
+  'pytest-cov',
+  'pytest-mock',
+  'coveralls',
+  'pep8-naming',
+  'flake8-annotations'
+]
 [project.urls]
 "Homepage" = "https://github.com/Beakerboy/vbaProject-Compiler"
 "Bug Tracker" = "https://github.com/Beakerboy/vbaProject-Compiler/issues"
@@ -26,3 +38,5 @@ pythonpath = "src"
 testpaths = [
     "tests",
 ]
+[tool.setuptools.package-data]
+"*" = ["*.cls"]

vbaProjectCompiler/Models/Entities/doc_module.py → src/ms_ovba/Models/Entities/doc_module.py

@@ -1,34 +1,29 @@
 from ms_ovba_compression.ms_ovba import MsOvba
-from vbaProjectCompiler.Models.Entities.module_base import ModuleBase
+from ms_ovba.Models.Entities.module_base import ModuleBase
+from typing import TypeVar
+
+
+T = TypeVar('T', bound='DocModule')
 
 
 class DocModule(ModuleBase):
     """
     A Document Module is a module record that is associated with a worksheet or
     workbook.
     """
-    def __init__(self, name):
-        self.docTlibVer = 0
+    def __init__(self: T, name: str) -> None:
+        self.doc_tlib_ver = 0
         super(DocModule, self).__init__(name)
         self.type = "Document"
 
         # GUIDs
         self._guid = []
 
-    def toProjectModuleString(self):
+    def to_project_module_string(self: T) -> str:
         return ("Document=" + self.modName.value + "/&H"
-                + self.docTlibVer.to_bytes(4, "big").hex())
-
-    def set_guid(self, guid):
-        if isinstance(guid, list):
-            self._guid = guid
-        else:
-            self._guid = [guid]
-
-    def add_guid(self, guid):
-        self._guid += guid
+                + self.doc_tlib_ver.to_bytes(4, "big").hex())
 
-    def normalize_file(self):
+    def normalize_file(self: T) -> None:
         f = open(self._file_path, "r")
         new_f = open(self._file_path + ".new", "a+", newline='\r\n')
         for i in range(5):
@@ -46,7 +41,7 @@ def normalize_file(self):
         new_f.writelines([self._attr("Customizable", "True")])
         new_f.close()
 
-    def write_file(self):
+    def write_file(self: T) -> None:
         bin_f = open(self._file_path + ".bin", "wb")
         bin_f.write(self._cache)
         with open(self._file_path + ".new", mode="rb") as new_f:

src/ms_ovba/Models/Entities/license_info.py

@@ -0,0 +1,24 @@
+import struct
+import uuid
+from typing import TypeVar
+
+
+T = TypeVar('T', bound='LicenseInfo')
+
+
+class LicenseInfo:
+    def __init__(self: T, guid: uuid.UUID, key: bytes) -> None:
+        self._guid = guid
+        self._key = key
+        self._required = len(key) > 0
+
+    def not_required(self: T) -> None:
+        self._required = False
+
+    def to_bytes(self: T) -> bytes:
+        return (
+            self._guid.bytes +
+            struct.pack("<I", len(self._key)) +
+            self._key +
+            struct.pack("<I", 1 if self._required else 0)
+        )

src/ms_ovba/Models/Entities/module_base.py

@@ -0,0 +1,117 @@
+from ms_ovba_compression.ms_ovba import MsOvba
+from ms_ovba.Models.Fields.doubleEncodedString import (
+    DoubleEncodedString
+)
+from ms_ovba.Models.Fields.packed_data import PackedData
+from ms_ovba.Models.Fields.idSizeField import IdSizeField
+from typing import TypeVar
+
+
+T = TypeVar('T', bound='ModuleBase')
+
+
+class ModuleBase():
+    def __init__(self: T, name: str) -> None:
+        """
+        Initialize the module record
+        """
+        self.modName = DoubleEncodedString([0x0019, 0x0047], name)
+        self.streamName = DoubleEncodedString([0x001A, 0x0032], name)
+        self.docString = DoubleEncodedString([0x001C, 0x0048], "")
+        self.helpContext = IdSizeField(0x001E, 4, 0)
+        self._cookie = IdSizeField(0x002C, 2, 0xFFFF)
+
+        # self.readonly = SimpleRecord(0x001E, 4, helpContext)
+        # self.private = SimpleRecord(0x001E, 4, helpContext)
+        self._cache = b''
+        self.workspace = [0, 0, 0, 0, 'C']
+        self.type = ''
+        self.created = 0
+        self.modified = 0
+        self._fileSize = 0
+        self._size = 0
+
+        # GUIDs
+        self._guids = []
+
+    @property
+    def guids(self: T) -> str:
+        return self._guids
+
+    @guids.setter
+    def guids(self: T, guid: str) -> None:
+        if isinstance(guid, list):
+            self._guids = guid
+        else:
+            self._guids = [guid]
+
+    def add_guid(self: T, guid: str) -> None:
+        """
+        Append a guid to the list
+        """
+        self._guid += [guid]
+
+    @property
+    def cache(self: T) -> bytes:
+        return self._cache
+
+    @cache.setter
+    def cache(self: T, cache: bytes) -> None:
+        self._cache = cache
+
+    @property
+    def cookie(self: T) -> int:
+        return self._cookie.value
+
+    @cookie.setter
+    def cookie(self: T, value: int) -> None:
+        self._cookie = IdSizeField(0x002C, 2, value)
+
+    @property
+    def name(self: T) -> str:
+        return self.modName.value
+
+    @property
+    def bin_path(self: T) -> str:
+        return self._file_path + ".bin"
+
+    def add_workspace(self: T, val1: int, val2: int,
+                      val3: int, val4: int, val5: int) -> None:
+        self.workspace = [val1, val2, val3, val4, val5]
+
+    def pack(self: T, endien: str, cp_name: str) -> bytes:
+        """
+        Pack the metadata for use in the dir stream.
+        """
+        typeid_value = 0x0022 if self.type == 'Document' else 0x0021
+        type_id = PackedData("HI", typeid_value, 0)
+        self.offsetRec = IdSizeField(0x0031, 4, len(self._cache))
+        output = (self.modName.pack(endien, cp_name)
+                  + self.streamName.pack(endien, cp_name)
+                  + self.docString.pack(endien, cp_name)
+                  + self.offsetRec.pack(endien)
+                  + self.helpContext.pack(endien, cp_name)
+                  + self._cookie.pack(endien)
+                  + type_id.pack(endien))
+        footer = PackedData("HI", 0x002B, 0)
+        output += footer.pack(endien)
+        return output
+
+    def to_project_module_string(self: T) -> str:
+        return self.type + "=" + self.modName.value
+
+    def add_file(self: T, file_path: str) -> None:
+        self._file_path = file_path
+
+    def write_file(self: T) -> None:
+        bin_f = open(self._file_path + ".bin", "wb")
+        bin_f.write(self._cache)
+        with open(self._file_path + ".new", mode="rb") as new_f:
+            contents = new_f.read()
+        ms_ovba = MsOvba()
+        compressed = ms_ovba.compress(contents)
+        bin_f.write(compressed)
+        bin_f.close()
+
+    def _attr(self: T, name: str, value: str) -> str:
+        return 'Attribute VB_' + name + ' = ' + value + '\n'