Rename tests/Unit/Models/test_vbaProject.py to tests/Unit/test_vbaPro…

.github/workflows/python-package.yml

@@ -41,6 +41,7 @@ jobs:
       run: |
         pytest --cov=src
         coveralls --service=github
+        ls -al
 
   flake8:
     runs-on: ubuntu-latest

src/ms_ovba/Models/Entities/module_base.py

@@ -19,7 +19,7 @@ def __init__(self: T, name: str) -> None:
         self.streamName = DoubleEncodedString([0x001A, 0x0032], name)
         self.docString = DoubleEncodedString([0x001C, 0x0048], "")
         self.helpContext = IdSizeField(0x001E, 4, 0)
-        self.cookie = IdSizeField(0x002C, 2, 0xFFFF)
+        self._cookie = IdSizeField(0x002C, 2, 0xFFFF)
 
         # self.readonly = SimpleRecord(0x001E, 4, helpContext)
         # self.private = SimpleRecord(0x001E, 4, helpContext)
@@ -32,55 +32,69 @@ def __init__(self: T, name: str) -> None:
         self._size = 0
 
         # GUIDs
-        self._guid = []
+        self._guids = []
 
-    def set_guid(self: T, guid: str) -> None:
+    @property
+    def guids(self: T) -> str:
+        return self._guids
+
+    @guids.setter
+    def guids(self: T, guid: str) -> None:
         if isinstance(guid, list):
-            self._guid = guid
+            self._guids = guid
         else:
-            self._guid = [guid]
+            self._guids = [guid]
 
     def add_guid(self: T, guid: str) -> None:
-        self._guid += guid
-
-    def set_cache(self: T, cache: bytes) -> None:
-        self._cache = cache
+        """
+        Append a guid to the list
+        """
+        self._guid += [guid]
 
-    def get_cache(self: T) -> bytes:
+    @property
+    def cache(self: T) -> bytes:
         return self._cache
 
-    def set_cookie(self: T, value: int) -> None:
-        self.cookie = IdSizeField(0x002C, 2, value)
+    @cache.setter
+    def cache(self: T, cache: bytes) -> None:
+        self._cache = cache
+
+    @property
+    def cookie(self: T) -> int:
+        return self._cookie.value
 
-    def get_cookie(self: T) -> int:
-        return self.cookie.value
+    @cookie.setter
+    def cookie(self: T, value: int) -> None:
+        self._cookie = IdSizeField(0x002C, 2, value)
 
-    def get_name(self: T) -> str:
+    @property
+    def name(self: T) -> str:
         return self.modName.value
 
-    def get_bin_path(self: T) -> str:
+    @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, codepage_name: str, endien: str) -> bytes:
+    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(codepage_name, endien)
-                  + self.streamName.pack(codepage_name, endien)
-                  + self.docString.pack(codepage_name, endien)
-                  + self.offsetRec.pack(codepage_name, endien)
-                  + self.helpContext.pack(codepage_name, endien)
-                  + self.cookie.pack(codepage_name, endien)
-                  + type_id.pack(codepage_name, endien))
+        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(codepage_name, endien)
+        output += footer.pack(endien)
         return output
 
     def to_project_module_string(self: T) -> str:

src/ms_ovba/Models/Entities/reference.py

@@ -13,21 +13,18 @@ class Reference():
     """
     2.3.4.2.2.1 REFERENCE Record
     """
-    def __init__(self: T, codepage_name: str,
-                 ref: ReferenceRecord,
+    def __init__(self: T, ref: ReferenceRecord,
                  name: str = None) -> None:
-        # is self._codepage_name even needed?
-        self._codepage_name = codepage_name
         self._ref = ref
         self._refname = name
 
-    def pack(self: T, cp_name: str, endien: str) -> bytes:
+    def pack(self: T, endien: str, cp_name: str) -> bytes:
         name_pack = b''
         if self._refname is not None:
             name_de = DoubleEncodedString([0x0016, 0x003E], self._refname)
-            name_pack = name_de.pack(cp_name, endien)
+            name_pack = name_de.pack(endien, cp_name)
 
-        return name_pack + self._ref.pack(cp_name, endien)
+        return name_pack + self._ref.pack(endien, cp_name)
 
     @staticmethod
     def unpack(data: bytes, endien: str) -> T:

src/ms_ovba/Models/Entities/reference_project.py

@@ -1,6 +1,6 @@
+import struct
 from ms_ovba.Models.Entities.reference_record import ReferenceRecord
 from ms_ovba.Models.Fields.project_reference import ProjectReference
-from ms_ovba.Models.Fields.packed_data import PackedData
 from typing import TypeVar
 
 
@@ -9,23 +9,19 @@
 
 class ReferenceProject(ReferenceRecord):
 
-    def __init__(self: T, codepage_name: str,
-                 ref: ProjectReference) -> None:
-        # is self._codepage_name even needed?
-        self._codepage_name = codepage_name
+    def __init__(self: T, ref: ProjectReference) -> None:
         self._ref = ref
 
-    def pack(self: T, cp_name: str, endien: str) -> bytes:
+    def pack(self: T, endien: str, cp_name: str) -> bytes:
+        endien_symbol = '<' if endien == 'little' else '>'
         lib_rel = self._ref.relative()
         libid_abs_size = len(self._ref)
         libid_rel_size = len(lib_rel)
-        format = ("HII" + str(libid_abs_size) + "sI" +
+        format = (endien_symbol + "HII" + str(libid_abs_size) + "sI" +
                   str(libid_rel_size) + "sIH")
         ref_str = str(self._ref).encode(cp_name)
         ref_str_rel = str(lib_rel).encode(cp_name)
-        ref_project = PackedData(format, 0x000E,
-                                 libid_abs_size + libid_rel_size + 14,
-                                 libid_abs_size, ref_str, libid_rel_size,
-                                 ref_str_rel, 0x65BE0257, 0x0017)
-
-        return (ref_project.pack(cp_name, endien))
+        return struct.pack(format, 0x000E,
+                           libid_abs_size + libid_rel_size + 14,
+                           libid_abs_size, ref_str, libid_rel_size,
+                           ref_str_rel, 0x65BE0257, 0x0017)

src/ms_ovba/Models/Entities/reference_registered.py

@@ -1,7 +1,6 @@
 import struct
 from ms_ovba.Models.Entities.reference_record import ReferenceRecord
 from ms_ovba.Models.Fields.libid_reference import LibidReference
-from ms_ovba.Models.Fields.packed_data import PackedData
 from typing import TypeVar
 
 
@@ -13,24 +12,20 @@ class ReferenceRegistered(ReferenceRecord):
     2.3.4.2.2.5
     Specifies a reference to an Automation type library.
     """
-    def __init__(self: T, codepage_name: str,
-                 libid_ref: LibidReference) -> None:
-        # is self._codepage_name even needed?
-        self._codepage_name = codepage_name
+    def __init__(self: T, libid_ref: LibidReference) -> None:
         self._libid_ref = libid_ref
 
     @property
     def libid(self: T) -> LibidReference:
         return self._libid_ref
 
-    def pack(self: T, cp_name: str, endien: str) -> bytes:
+    def pack(self: T, endien: str, cp_name: str) -> bytes:
+        endien_symbol = '<' if endien == 'little' else '>'
         strlen = len(self._libid_ref)
-        format = "HII" + str(strlen) + "sIH"
+        format = endien_symbol + "HII" + str(strlen) + "sIH"
         lib_str = str(self._libid_ref).encode(cp_name)
-        ref_registered = PackedData(format, 0x000D, strlen + 10,
-                                    strlen, lib_str, 0, 0)
-
-        return ref_registered.pack(cp_name, endien)
+        return struct.pack(format, 0x000D, strlen + 10,
+                           strlen, lib_str, 0, 0)
 
     @staticmethod
     def unpack(data: bytes, endien: str) -> T:
@@ -66,4 +61,4 @@ def unpack(data: bytes, endien: str) -> T:
             pass
 
         libid_ref = LibidReference.unpack(libid_ref_bytes)
-        return ReferenceRegistered("", libid_ref)
+        return ReferenceRegistered(libid_ref)

src/ms_ovba/Models/Fields/doubleEncodedString.py

@@ -12,13 +12,17 @@ class DoubleEncodedString():
     """
     def __init__(self: T, ids: list, text: str) -> None:
         self.ids = ids
-        self.value = text
+        self._value = text
 
-    def pack(self: T, codepage_name: str, endien: str) -> bytes:
-        encoded = self.value.encode(codepage_name)
+    @property
+    def value(self) -> str:
+        return self._value
+
+    def pack(self: T, endien: str, cp_name: str) -> bytes:
+        encoded = self._value.encode(cp_name)
         self.mod_name1 = IdSizeField(self.ids[0], len(encoded), encoded)
         format = "utf_16_le" if endien == 'little' else "utf_16_be"
-        encoded = self.value.encode(format)
+        encoded = self._value.encode(format)
         self.mod_name2 = IdSizeField(self.ids[1], len(encoded), encoded)
-        return (self.mod_name1.pack(codepage_name, endien)
-                + self.mod_name2.pack(codepage_name, endien))
+        return (self.mod_name1.pack(endien)
+                + self.mod_name2.pack(endien))

src/ms_ovba/Models/Fields/idSizeField.py

@@ -16,14 +16,17 @@ def __init__(self: T, id: int, size: int, value: Any) -> None:
         self._size = size
         self._value = value
 
-    def pack(self: T, codepage_name: str, endien: str) -> bytes:
+    @property
+    def value(self: T) -> Any:
+        return self._value
+
+    def pack(self: T, endien: str, cp_name: str = None) -> bytes:
         endien_symbol = '<' if endien == 'little' else '>'
         format = endien_symbol + "HI"
         if isinstance(self._value, str):
             self.stringValue = self._value
             self._value = bytes(self._value, encoding="ascii")
-            format += str(self._size) + "s"
-        elif isinstance(self._value, bytes):
+        if isinstance(self._value, bytes):
             format += str(self._size) + "s"
         elif self._size == 2:
             format += "H"

src/ms_ovba/Models/Fields/packed_data.py

@@ -7,12 +7,14 @@
 
 class PackedData():
     """
-    Multivalue field with a packing format
+    Multivalue field with a packing format.
+    This class allows a user to define a data format,
+    and render it at a later time.
     """
     def __init__(self: T, format: str, *values: Any) -> None:
         self.values = values
         self.format = format
 
-    def pack(self: T, codepage_name: str, endien: str) -> bytes:
+    def pack(self: T, endien: str, cp_name: str = None) -> bytes:
         endien_symbol = '<' if endien == 'little' else '>'
         return struct.pack(endien_symbol + self.format, *self.values)

src/ms_ovba/Views/dirStream.py

@@ -19,30 +19,30 @@ class DirStream():
 
     def __init__(self: T, project: VbaProject) -> None:
         self.project = project
-        self._include_compat = False
+        self._include_compat = project.compat
 
     def to_bytes(self: T) -> bytes:
         information = self._load_information()
         endien = self.project.endien
-        codepage_name = self.project.get_codepage_name()
+        cp_name = self.project.codepage_name
         pack_symbol = '<' if endien == 'little' else '>'
         # should be 0xFFFF
-        cookie_value = self.project.get_project_cookie()
+        cookie_value = self.project.project_cookie
         self.project_cookie = IdSizeField(19, 2, cookie_value)
         references = self.project.references
         modules = self.project.modules
         output = b''
         for record in information:
-            output += record.pack(codepage_name, endien)
+            output += record.pack(endien, cp_name)
         for record in references:
-            output += record.pack(codepage_name, endien)
+            output += record.pack(endien, cp_name)
 
         modules_header = IdSizeField(0x000F, 2, len(modules))
 
-        output += (modules_header.pack(codepage_name, endien)
-                   + self.project_cookie.pack(codepage_name, endien))
+        output += (modules_header.pack(endien)
+                   + self.project_cookie.pack(endien))
         for record in modules:
-            output += record.pack(codepage_name, endien)
+            output += record.pack(endien, cp_name)
         output += struct.pack(pack_symbol + "HI", 16, 0)
         return output
 

src/ms_ovba/Views/project.py

@@ -16,7 +16,7 @@ def __init__(self: T, project: VbaProject) -> None:
         # Attributes
 
         # A list of attributes and values
-        self.attributes = {}
+        self.attributes = project.attributes
 
         # The HostExtenderInfo string
         guid = "{3832D640-CF90-11CF-8E43-00A0C911005A}"
@@ -27,10 +27,10 @@ def add_attribute(self: T, name: str, value: str) -> None:
 
     def to_bytes(self: T) -> bytes:
         project = self.project
-        codepage_name = project.get_codepage_name()
+        codepage_name = project.codepage_name
         # Use \x0D0A line endings...however python encodes that.
         eol = b'\x0D\x0A'
-        project_id = project.get_project_id()
+        project_id = project.project_id
         id = bytearray(project_id, codepage_name)
         result = b'ID="' + id + b'"' + eol
         modules = project.modules
@@ -42,10 +42,10 @@ def to_bytes(self: T) -> bytes:
             result += self._attr(key, self.attributes[key])
         cmg = ms_ovba_crypto.encrypt(
                                      project_id,
-                                     project.get_protection_state()
+                                     project.protection_state
                                     )
-        dpb = ms_ovba_crypto.encrypt(project_id, project.get_password())
-        gc = ms_ovba_crypto.encrypt(project_id, project.get_visibility_state())
+        dpb = ms_ovba_crypto.encrypt(project_id, project.password)
+        gc = ms_ovba_crypto.encrypt(project_id, project.visibility_state)
         result += (bytes('CMG="', codepage_name)
                    + binascii.hexlify(cmg).upper()
                    + b'\x22\x0D\x0A')
@@ -74,7 +74,7 @@ def write_file(self: T) -> None:
         bin_f.close()
 
     def _attr(self: T, name: str, value: str) -> str:
-        codepage_name = self.project.get_codepage_name()
+        codepage_name = self.project.codepage_name
         eol = b'\x0D\x0A'
         b_name = bytes(name, codepage_name)
         b_value = bytes(value, codepage_name)

src/ms_ovba/Views/project_ole_file.py

@@ -33,7 +33,7 @@ def _build_ole_directory(project: VbaProject) -> RootDirectory:
         storage.set_modified(project.default_date)
         for module in project.get_modules():
             module.write_file()
-            dir = StreamDirectory(module.get_name(), module.get_bin_path())
+            dir = StreamDirectory(module.name, module.bin_path)
             storage.add_directory(dir)
 
         module = DirStream(project)
@@ -48,7 +48,7 @@ def _build_ole_directory(project: VbaProject) -> RootDirectory:
 
         directory.add_directory(storage)
 
-        if project.get_include_projectwm():
+        if project.projectwm:
             module = ProjectWm(project)
             module.write_file()
             stream = StreamDirectory("PROJECTwm", "projectwm.bin")