Launcher/core_lib/game/argument.py

import logging
import shlex

from core_lib.game.library import get_natives_platform_info

logger = logging.getLogger("Launcher.CoreLib")

def is_argument_allowed(argument: dict | str, allow_features: dict=dict) -> bool:
    """
    Check if argument is allowed or not.
    :param argument:
    :param allow_features: Should be like {key: value}
    :return:
        allowed: bool
    """
    if isinstance(argument, str):
        return True

    rules = argument.get('rules', {})

    _, platform_rule_name, _ = get_natives_platform_info()

    allowed = False

    if not rules:
        return True

    for rule in rules:
        rule_action = rule.get("action", None)
        os_section = rule.get("os", {})
        rule_os = os_section.get("name", None)
        features_rule = rule.get("features", None)

        if rule_os is not None and platform_rule_name != rule_os:
            continue

        matched = True

        # Check feature dict
        if features_rule:
            for key, expected in features_rule.items():
                if allow_features.get(key, False) != expected:
                    matched = False
                    break

        if not matched:
            continue


        if rule_action == "allow":
            allowed = True
        elif rule_action == "disallow":
            allowed = False
        else:
            logger.warning(f"Unknown action {rule_action}\n")

    return allowed

def replace_placeholders(argument, placeholders: dict) -> str:
    if argument:
        for key, value in placeholders.items():
            argument = argument.replace("${" + key + "}", "" if value is None else str(value))

    return argument

class ArgumentMappings:
    def __init__(self, player_name="Player", version_name="unknown",
                 game_directory=None, assets_root=None, assets_index_name=None,
                 auth_uuid="00000001-0002-0003-0004-000000000005",
                 auth_access_token="", clientid=None, auth_xuid=None,
                 user_type=None, version_type=None, natives_directory=None,
                 launcher_name=None, launcher_version=None,
                 classpath=None, classpath_separator=None, library_directory=None):
        self.player_name = player_name
        self.version_name = version_name
        self.game_directory = game_directory
        self.assets_root = assets_root
        self.assets_index_name = assets_index_name
        self.auth_uuid = auth_uuid
        self.auth_access_token = auth_access_token
        self.clientid = clientid
        self.auth_xuid = auth_xuid
        self.user_type = user_type
        self.version_type = version_type
        self.natives_directory = natives_directory
        self.launcher_name = launcher_name
        self.launcher_version = launcher_version
        self.classpath = classpath
        self.classpath_separator = classpath_separator
        self.library_directory = library_directory

    def generate_placeholders(self):
        return {
            "player_name": self.player_name,
            "version_name": self.version_name,
            "game_directory": self.game_directory,
            "assets_root": self.assets_root,
            "assets_index_name": self.assets_index_name,
            "auth_uuid": self.auth_uuid,
            "auth_access_token": self.auth_access_token,
            "auth_player_name": self.player_name,
            "clientid": self.clientid,
            "auth_xuid": self.auth_xuid,
            "user_type": self.user_type,
            "version_type": self.version_type,
            "natives_directory": self.natives_directory,
            "launcher_name": self.launcher_name,
            "launcher_version": self.launcher_version,
            "classpath": self.classpath,
            "classpath_separator": self.classpath_separator,
            "library_directory": self.library_directory
        }

def convert_argument_to_multiple_string(argument: str | dict) -> list[str]:
    if isinstance(argument, str):
        return [argument]

    if isinstance(argument, dict):
        value = argument.get("value", None)

        if isinstance(value, list):
            return [str(item) for item in value] # ensure all item are string
        elif isinstance(value, str):
            return [value]

    raise TypeError("Argument must be of type str or dict")

def parse_and_generate_arguments(arguments: list | str, mappings: ArgumentMappings, features: dict=dict) -> list[str]:
    parsed_arguments = []

    if isinstance(arguments, str):
        # Convert legacy argument into a list type
        arguments = shlex.split(arguments)

    placeholders = mappings.generate_placeholders()

    for argument in arguments:
        # Check rules
        if not is_argument_allowed(argument, allow_features=features):
            continue

        # Each argument (section) may contain multiple items, convert it to list before replace placeholder
        converted = convert_argument_to_multiple_string(argument)

        for item in converted:
            parsed = replace_placeholders(item, placeholders)
            parsed_arguments.append(parsed)

    return parsed_arguments