arguments.py: Rework into object oriented

resources/arguments.py

@@ -9,19 +9,92 @@ import logging
 
 # Generic building args
 class arguments:
-    def __init__(self):
+    def __init__(self, constants):
         self.args = utilities.check_cli_args()
+        self.constants = constants
+
+        self._parse_arguments()
+
+
+    def _parse_arguments(self):
+        """
+        Parses arguments passed to the patcher
+        """
 
-    def parse_arguments(self, settings):
         if self.args.validate:
-            validation.validate(settings)
+            self._validation_handler()
-        elif self.args.build:
+            return
+
+        if self.args.build:
+            self._build_handler()
+            return
+
+        if self.args.patch_sys_vol:
+            self._sys_patch_handler()
+            return
+
+        if self.args.unpatch_sys_vol:
+            self._sys_unpatch_handler()
+            return
+
+        if self.args.auto_patch:
+            self._sys_patch_auto_handler()
+            return
+
+
+    def _validation_handler(self):
+        """
+        Enter validation mode
+        """
+
+        validation.PatcherValidation(self.constants)
+
+
+    def _sys_patch_handler(self):
+        """
+        Start root volume patching
+        """
+
+        logging.info("- Set System Volume patching")
+        if "Library/InstallerSandboxes/" in str(self.constants.payload_path):
+            logging.info("- Running from Installer Sandbox")
+            thread = threading.Thread(target=sys_patch.PatchSysVolume(self.constants.custom_model or self.constants.computer.real_model, self.constants, None).start_patch)
+            thread.start()
+            while thread.is_alive():
+                utilities.block_os_updaters()
+                time.sleep(1)
+        else:
+            sys_patch.PatchSysVolume(self.constants.custom_model or self.constants.computer.real_model, self.constants, None).start_patch()
+
+
+    def _sys_unpatch_handler(self):
+        """
+        Start root volume unpatching
+        """
+        logging.info("- Set System Volume unpatching")
+        sys_patch.PatchSysVolume(self.constants.custom_model or self.constants.computer.real_model, self.constants, None).start_unpatch()
+
+
+    def _sys_patch_auto_handler(self):
+        """
+        Start root volume auto patching
+        """
+
+        logging.info("- Set Auto patching")
+        sys_patch_auto.AutomaticSysPatch(self.constants).start_auto_patch()
+
+
+    def _build_handler(self):
+        """
+        Start config building process
+        """
+
         if self.args.model:
             if self.args.model:
                 logging.info(f"- Using custom model: {self.args.model}")
-                    settings.custom_model = self.args.model
+                self.constants.custom_model = self.args.model
-                    defaults.generate_defaults(settings.custom_model, False, settings)
+                defaults.generate_defaults(self.constants.custom_model, False, self.constants)
-                elif settings.computer.real_model not in model_array.SupportedSMBIOS and settings.allow_oc_everywhere is False:
+            elif self.constants.computer.real_model not in model_array.SupportedSMBIOS and self.constants.allow_oc_everywhere is False:
                 logging.info(
                     """Your model is not supported by this patcher for running unsupported OSes!"
 
@@ -29,88 +102,85 @@ class arguments:
                 )
                 sys.exit(1)
             else:
-                    logging.info(f"- Using detected model: {settings.computer.real_model}")
+                logging.info(f"- Using detected model: {self.constants.computer.real_model}")
-                    defaults.generate_defaults(settings.custom_model, True, settings)
+                defaults.generate_defaults(self.constants.custom_model, True, self.constants)
 
         if self.args.disk:
             logging.info(f"- Install Disk set: {self.args.disk}")
-                settings.disk = self.args.disk
+            self.constants.disk = self.args.disk
+
         if self.args.verbose:
             logging.info("- Set verbose configuration")
-                settings.verbose_debug = True
+            self.constants.verbose_debug = True
         else:
-                settings.verbose_debug = False  # Override Defaults detected
+            self.constants.verbose_debug = False  # Override Defaults detected
+
         if self.args.debug_oc:
             logging.info("- Set OpenCore DEBUG configuration")
-                settings.opencore_debug = True
+            self.constants.opencore_debug = True
-                settings.opencore_build = "DEBUG"
+            self.constants.opencore_build = "DEBUG"
+
         if self.args.debug_kext:
             logging.info("- Set kext DEBUG configuration")
-                settings.kext_debug = True
+            self.constants.kext_debug = True
+
         if self.args.hide_picker:
             logging.info("- Set HidePicker configuration")
-                settings.showpicker = False
+            self.constants.showpicker = False
+
         if self.args.disable_sip:
             logging.info("- Set Disable SIP configuration")
-                settings.sip_status = False
+            self.constants.sip_status = False
         else:
-                settings.sip_status = True  # Override Defaults detected
+            self.constants.sip_status = True  # Override Defaults detected
+
         if self.args.disable_smb:
             logging.info("- Set Disable SecureBootModel configuration")
-                settings.secure_status = False
+            self.constants.secure_status = False
         else:
-                settings.secure_status = True  # Override Defaults detected
+            self.constants.secure_status = True  # Override Defaults detected
+
         if self.args.vault:
             logging.info("- Set Vault configuration")
-                settings.vault = True
+            self.constants.vault = True
+
         if self.args.firewire:
             logging.info("- Set FireWire Boot configuration")
-                settings.firewire_boot = True
+            self.constants.firewire_boot = True
+
         if self.args.nvme:
             logging.info("- Set NVMe Boot configuration")
-                settings.nvme_boot = True
+            self.constants.nvme_boot = True
+
         if self.args.wlan:
             logging.info("- Set Wake on WLAN configuration")
-                settings.enable_wake_on_wlan = True
+            self.constants.enable_wake_on_wlan = True
+
         if self.args.disable_tb:
             logging.info("- Set Disable Thunderbolt configuration")
-                settings.disable_tb = True
+            self.constants.disable_tb = True
+
         if self.args.force_surplus:
             logging.info("- Forcing SurPlus override configuration")
-                settings.force_surplus = True
+            self.constants.force_surplus = True
+
         if self.args.moderate_smbios:
             logging.info("- Set Moderate SMBIOS Patching configuration")
-                settings.serial_settings = "Moderate"
+            self.constants.serial_settings = "Moderate"
+
         if self.args.smbios_spoof:
             if self.args.smbios_spoof == "Minimal":
-                    settings.serial_settings = "Minimal"
+                self.constants.serial_settings = "Minimal"
             elif self.args.smbios_spoof == "Moderate":
-                    settings.serial_settings = "Moderate"
+                self.constants.serial_settings = "Moderate"
             elif self.args.smbios_spoof == "Advanced":
-                    settings.serial_settings = "Advanced"
+                self.constants.serial_settings = "Advanced"
             else:
                 logging.info(f"- Unknown SMBIOS arg passed: {self.args.smbios_spoof}")
 
         if self.args.support_all:
             logging.info("- Building for natively supported model")
-                settings.allow_oc_everywhere = True
+            self.constants.allow_oc_everywhere = True
-                settings.serial_settings = "None"
+            self.constants.serial_settings = "None"
-            build.build_opencore(settings.custom_model or settings.computer.real_model, settings).build_opencore()
-        elif self.args.patch_sys_vol:
-            logging.info("- Set System Volume patching")
 
-            if "Library/InstallerSandboxes/" in str(settings.payload_path):
+        build.build_opencore(self.constants.custom_model or self.constants.computer.real_model, self.constants).build_opencore()
-                logging.info("- Running from Installer Sandbox")
-                thread = threading.Thread(target=sys_patch.PatchSysVolume(settings.custom_model or settings.computer.real_model, settings, None).start_patch)
-                thread.start()
-                while thread.is_alive():
-                    utilities.block_os_updaters()
-                    time.sleep(1)
-            else:
-                sys_patch.PatchSysVolume(settings.custom_model or settings.computer.real_model, settings, None).start_patch()
-        elif self.args.unpatch_sys_vol:
-            logging.info("- Set System Volume unpatching")
-            sys_patch.PatchSysVolume(settings.custom_model or settings.computer.real_model, settings, None).start_unpatch()
-        elif self.args.auto_patch:
-            logging.info("- Set Auto patching")
-            sys_patch_auto.AutomaticSysPatch(settings).start_auto_patch()