onboard.py

# Description: This script is used to onboard a project onto Wrench
import argparse
import json
import os
import shutil
import subprocess

TEMPLATE_CSPROJ = "TEMPLATE.Cookbook.csproj"
TEMPLATE_SLN = "TEMPLATE-recipes.sln"


def get_args():
    parser = argparse.ArgumentParser(description="Onboard a project onto Wrench")
    parser.add_argument("--settings-name", required=True, help="The name of the settings file",
                        dest="settings_name")
    return parser.parse_args()


def delete_git_folder():
    print("Deleting .git folder")
    if os.path.isfile(".gitignore"):
        os.remove(".gitignore")
    if os.path.exists(".git"):
        shutil.rmtree(".git", ignore_errors=True)


def get_git_root_dir():
    git_dir = subprocess.run(["git", "rev-parse", "--show-toplevel"], stdout=subprocess.PIPE).stdout
    return git_dir.decode("utf-8").strip()


def find_package_json_files(root_dir, initial=True):
    #walk the directory recursively and find all package.json files
    rtn_list = set()
    for root, dirs, files in os.walk(root_dir):
        for file in files:
            if file == "package.json":
                if initial:
                    file_location = file
                else:
                    file_location = os.path.join(root, file)
                # validate the package.json file
                with open(os.path.join(root, file_location), "r") as f:
                    data = json.loads(f.read())
                    if "unity" in data and "name" in data:
                        rtn_list.add(data["name"])
        for directory in dirs:
            rtn_list.update(find_package_json_files(os.path.join(root, directory), False))

    return rtn_list


def create_package_option(name, first):
    initial_char=""
    initial_tab = ""
    if not first:
        initial_char = ",\n"
        initial_tab = "        "
    return f"{initial_char}{initial_tab}{{\n            \"{name}\",\n            new PackageOptions() {{ ReleaseOptions = new ReleaseOptions() {{ IsReleasing = true }} }}\n        }}"


def update_template_variables(packages):
    template_var = "TEMPLATESettings"
    settings = get_args()
    settings_content = open(os.path.join("Settings", template_var+".cs")).read()
    # replace the template settings with the actual settings
    settings_content = settings_content.replace("TEMPLATESettings", f"{settings.settings_name}Settings")
    settings_content = settings_content.replace('PACKAGES_ROOTS', '.')

    package_replace_string = str()
    first = True
    for package in packages:
        package_replace_string += create_package_option(package, first)
        first = False
    settings_content = settings_content.replace('//"PACKAGES_TO_RELEASE"', package_replace_string)
    settings_content = settings_content.replace('TEMPLATE.Cookbook.Settings', settings.settings_name+".Cookbook.Settings")

    # Write the updated settings file
    with open(os.path.join("Settings", settings.settings_name+"Settings.cs"), "w") as f:
        f.write(settings_content)
    # Update the Program.cs file
    program_content = open("Program.cs").read()
    with open("Program.cs", "w") as f:
        program_content = program_content.replace('using TEMPLATE.Cookbook.Settings;', f"using {settings.settings_name}.Cookbook.Settings;")
        program_content = program_content.replace("TEMPLATE.Cookbook", settings.settings_name)
        program_content = program_content.replace('PACKAGES_ROOT', '.')
        program_content = program_content.replace('TEMPLATESettings', settings.settings_name+"Settings")
        f.write(program_content)
    # delete the template file
    os.remove(os.path.join("Settings", template_var+".cs"))
    # update csproj file
    csproj_content = open(TEMPLATE_CSPROJ).read()
    with open(TEMPLATE_CSPROJ.replace("TEMPLATE", settings.settings_name), "w") as f:
        f.write(csproj_content)
    os.remove(TEMPLATE_CSPROJ)
    # update sln file
    sln_content = open(TEMPLATE_SLN).read()
    with open(TEMPLATE_SLN.replace("TEMPLATE", settings.settings_name), "w") as f:
        sln_content = sln_content.replace("TEMPLATE", settings.settings_name)
        f.write(sln_content)
    os.remove(TEMPLATE_SLN)


def update_shell_scripts(root_dir):
    split_root=os.path.normpath(root_dir).split(os.sep)
    split_cwd=os.getcwd().split(os.sep)

    relative_path = os.path.relpath(os.getcwd(), root_dir)
    csproj_path = os.path.join(relative_path, f"{get_args().settings_name}.Cookbook.csproj")

    path_diff = len(split_cwd) - len(split_root)
    cd_string = str()
    for i in range(path_diff):
        cd_string += "../"

    bash_content = open("regenerate.bat").read()
    bash_content = bash_content.replace("STEPS_TO_ROOT", cd_string)
    bash_content = bash_content.replace("PATH_TO_CSPROJ", csproj_path)
    with open("regenerate.bat", "w") as f:
        f.write(bash_content)

    shell_content = open("regenerate.sh").read()
    shell_content = shell_content.replace("STEPS_TO_ROOT", cd_string)
    shell_content = shell_content.replace("PATH_TO_CSPROJ", csproj_path)
    with open("regenerate.sh", "w") as f:
        f.write(shell_content)


def main():
    print("Starting process of onboarding")
    # delete git folder
    delete_git_folder()
    # get root folder
    root_dir = get_git_root_dir()
    # find all appropriate package.json files
    package_files = find_package_json_files(root_dir)
    packages = set()
    # process out any testing packages
    for package in package_files:
        if ".tests" in package:
            continue
        packages.add(package)
    # Replace Template naming with actual naming
    update_template_variables(packages)
    update_shell_scripts(root_dir)


if "__main__" in __name__:
    main()