main.py

'''Generates and writes a manifest.json file for a Firefox add-on.

Author: Oscar Sanderson
Version: 0.9 (beta)
'''

import json

class ProjectGenerator:
    def __init__(self):
        '''
        Declares all attributes used.
        '''
        self.__user_input_obtained = False
        self.__manifest_version = None
        self.__extension_name = None
        self.__extension_version = None
        self.__extension_description = None
        self.__extension_author = None
        self.__extension_id = None
        self.__extension_icon_path = None
        self.__extension_icon_size = None
        self.__extension_domain_scope = None
        self.__user_data_permissions = []
        self.__main_background_script = None
        self.__main_content_script = None
        self.__homepage = None
        self.___settings_page = None
    
    def generate_manifest(self):
        '''
        Uses the JSON module to return the manifest.json contents.
        This returned data is then written to the manifest.json file.
        '''

        if not self.__user_input_obtained:
            print("Manifest cannot be generated as user input has not yet been obtained.")
            return None

        # Returns the JSON with identation to ensure it is readable
        return json.dumps(
            {
                "manifest_version": self.__manifest_version,
                "name": self.__extension_name,
                "version": self.__extension_version,
                "description": self.__extension_description,
                "icons": {
                    self.__extension_icon_size: self.__extension_icon_path
                },

                "browser_specific_settings": {
                    "gecko": {
                        "id": self.__extension_id,
                        "data_collection_permissions": {
                            "required": self.__user_data_permissions
                        }
                    }
                },

                "background": {
                        "scripts": [self.__main_background_script]
                },

                "content_scripts": [
                    {
                        "matches": [self.__extension_domain_scope],
                        "js": [self.__main_content_script]
                    }
                ]
            },
            indent = 4 
            )
    
    def __write_manifest(self) -> bool:
        '''
        Writes the manifest.json file using the generate_manifest method to obtain its contents.
        '''

        manifest_to_write = self.generate_manifest()

        if not manifest_to_write:
            print("Manifest cannot be written to file as no manifest has been returned")
            return False
        
        main_file = open("manifest.json", "w")
        main_file.write(manifest_to_write)
        main_file.close()

        return True

    def handle_input(function_in) -> None:
        '''
        Decorator method for all user input obtained for the setup
        '''
        
        def wrapper(self, input_msg, error_msg, user_input = None):
            input_obtained = False

            while not input_obtained:
                try:
                    user_input = input(input_msg)

                    get_id_input = function_in(self, input_msg, error_msg, user_input)

                    if get_id_input == ValueError:
                        raise ValueError
                    else:
                        input_obtained = True

                except Exception as e:
                    print(f"Exception `{e}` encountered. {error_msg}")

        return wrapper
    
    @handle_input
    def __handle_extension_name_input(self, input_msg, error_msg, user_input) -> None:
        if len(user_input) > 50:
            print("Extension name is too long!")
            raise ValueError
        
        self.__extension_name = user_input

    @handle_input
    def __handle_version_input(self, input_msg, error_msg, user_input) -> None:
        user_input_float = float(user_input)
        if user_input_float <= 0:
            print("Please enter an extension version greater than zero.")
            raise ValueError

        self.__extension_version = user_input

    @handle_input
    def __handle_description_input(self, input_msg, error_msg, user_input) -> None:
        self.__extension_description = user_input

    @handle_input
    def __handle_id_input(self, input_msg, error_msg, user_input) -> None:
        if len(user_input) > 30:
            print("Invalid ID. Too long!")
            raise ValueError
        
        self.__extension_id = user_input

    @handle_input
    def __handle_icons_input(self, input_msg, error_msg, user_input) -> None:
        # Converts icon_size to a float to check that the size inputted is a number
        icon_size = input("Please enter the icon size (For example: 48): ")
        icon_size_float = float(icon_size)
        
        # Checks if icon size is not positive
        if icon_size_float <= 0:
            print("Please enter a positive icon size.")
            raise ValueError

        self.__extension_icon_path = user_input
        self.__extension_icon_size = icon_size
    
    @handle_input
    def __handle_manifest_version_input(self, input_msg, error_msg, user_input) -> None:
        '''
        Casts manifest version entered to string after guard clause is checked
        '''

        if user_input not in ("2", "3"):
            print("Enter the manifest version! (either 2 or 3)")
            raise ValueError

        self.__manifest_version = int(user_input)

    @handle_input
    def __handle_data_permissions_input(self, input_msg, error_msg, user_input) -> None:
        no_other_permissions = False

        # If the user does not enter any permissions, it will default to none
        if user_input == "":
            no_other_permissions = True
            self.__extension_data_permissions = "none"

        while not no_other_permissions:
            other_permissions = input("Are any other permissions required? (y/n)")

            if other_permissions not in ("y", "n", "Y", "N"):
                print("Invalid response. Please re-enter the data permissions required.")
                raise ValueError
            
            if other_permissions in ("y", "Y"):
                other_permission_input = input("Please enter that data permission: ")
                self.__user_data_permissions.append(other_permission_input)
            else:
                no_other_permissions = True
            
            self.__user_data_permissions.append(user_input)
    
    @handle_input
    def __handle_domain_scope_input(self, input_msg, error_msg, user_input) -> None:
        '''
        Checks if the "a" argument has been passed in (all domains)
        Sets the domain scope attribute accordingly
        '''
        if user_input in ("a", "A"):
            self.__extension_domain_scope = "*://*/*"
        else:
            self.__extension_domain_scope = user_input

    @handle_input
    def __handle_author_input(self, input_msg, error_msg, user_input) -> None:
        self.__extension_author = user_input

    @handle_input
    def __handle_content_script_input(self, input_msg, error_msg, user_input) -> None:
        if user_input == "":
            self.__main_content_script = "none"

        self.__main_content_script = user_input

    @handle_input
    def __handle_background_script_input(self, input_msg, error_msg, user_input) -> None:
        if user_input == "":
            self.__main_background_script = "none"

        self.__main_background_script = user_input
    
    @handle_input
    def __handle_homepage_input(self, input_msg, error_msg, user_input) -> None:
        self.___homepage = user_input
        
    @handle_input
    def __handle_settings_page_input(self, input_msg, error_msg, user_input) -> None:
        if user_input == "":
            self.___settings_page = "none"
        
        self.___settings_page = user_input

    def __return_input_prompt(self, prompt_msg, allow_blank) -> str:
        '''
        Returns the template prompt with the specific prompt required.
        '''
        allow_blank_text = ""

        if allow_blank:
            allow_blank_text = " (press enter if not applicable)"
        
        return f"Please enter the {prompt_msg}{allow_blank_text}: "

    def __return_error_message(self, prompt_msg) -> str:
        return f"{prompt_msg} provided was invalid. Please enter a valid {prompt_msg.lower()}."

    def main(self) -> None:
        try:
            self.__handle_extension_name_input(self.__return_input_prompt("extension's name", False), self.__return_error_message("Extension name"))

            self.__handle_version_input(self.__return_input_prompt("extension version", False), self.__return_error_message("Version number")) 

            self.__handle_description_input(self.__return_input_prompt("extension description", False), self.__return_error_message("Description"))

            self.__handle_author_input(self.__return_input_prompt("author", True), self.__return_error_message("Author name")) 

            self.__handle_id_input(self.__return_input_prompt("extension ID", False), self.__return_error_message("ID"))

            self.__handle_icons_input(self.__return_input_prompt("main icon path", False), self.__return_error_message("An icon path"))

            self.__handle_manifest_version_input(self.__return_input_prompt("manifest version (either 2 or 3)", False), self.__return_error_message("Manifest version"))

            self.__handle_data_permissions_input(self.__return_input_prompt("first data permission required", True), self.__return_error_message("A data permission"))

            self.__handle_homepage_input(self.__return_input_prompt("extension homepage", True), self.__return_error_message("Extension homepage URL"))

            self.__handle_domain_scope_input(self.__return_input_prompt("domain scope (enter a for all URLs)", False), self.__return_error_message("Domain scope"))

            self.__handle_background_script_input(self.__return_input_prompt("path of the main background script file", True), self.__return_error_message("A background script path"))

            self.__handle_content_script_input(self.__return_input_prompt("path of the main content script file", True), self.__return_error_message("A content script path"))
            
            self.__handle_settings_page_input(self.__return_input_prompt("extension's settings page", True), self.__return_error_message("Extension settings page path"))
            
            self.__user_input_obtained = True

        except Exception as e:
            print(f"There as been a fatal exception when getting user input. Exception: {e}")

        try:
            self.__write_manifest()

        except Exception as e:
            print(f"There as been a fatal exception when writing the manifest. Exception: {e}")

        print("Project setup done!")


project_generator = ProjectGenerator()
project_generator.main()