fix_android_dependencies.py

import json
import os
import re

# These will have to be updated manually over time, there's not an
# easy way to determine the latest version.
COMPILE_SDK_VERSION = 36
TARGET_SDK_VERSION = 36
BUILD_TOOLS_VERSION = '36.0.0'

# build.gradle(.kts) files
COMPILE_SDK_RE = r'compileSdk(?:Version)?\s*=?\s*[\w]+'
TARGET_SDK_RE = r'targetSdk(?:Version)?\s*=?\s*[\w]+'
BUILD_TOOLS_RE = r'buildTools(?:Version)?\s*=?\s*[\'\"\w\.]+'

# *.versions.toml files
VERSION_RE = r'(.*)\s*=\s*"(.*)"'
DEPENDENCY_RE = r'(group|module|name|version|version.ref|id)\s*='

# Depends on https://github.com/ben-manes/gradle-versions-plugin
#
# Must run this command:
# $ ./gradlew dependencyUpdates -Drevision=release -DoutputFormatter=json
RELATIVE_PATH_TO_JSON_REPORT = 'build/dependencyUpdates/report.json'
# Default Gradle Version Catalog location
RELATIVE_PATH_TO_TOML = 'gradle/libs.versions.toml'


def find_configuration_files():
    """Finds all build configuration files, recursively."""
    gradle_files = []
    for root, dirs, files in os.walk('.'):
        for filename in files:
            if filename.endswith(('build.gradle', 'build.gradle.kts', 'versions.toml')):
                gradle_files.append(os.path.join(root, filename))

    return gradle_files


def get_android_replacements():
    """Gets a dictionary of all android-specific replacements to be made."""
    replacements = {}

    compile_sdk = f"compileSdk = {COMPILE_SDK_VERSION}"
    target_sdk = f"targetSdk = {TARGET_SDK_VERSION}"
    build_tools_version = f"buildToolsVersion = \"{BUILD_TOOLS_VERSION}\""

    replacements[COMPILE_SDK_RE] = compile_sdk
    replacements[TARGET_SDK_RE] = target_sdk
    replacements[BUILD_TOOLS_RE] = build_tools_version

    return replacements


def is_major_update(old_version, new_version):
    """Compares version strings to see if it's a major update."""
    old_major = old_version.split('.')[0]
    new_major = new_version.split('.')[0]

    return old_major != new_major


def get_dep_replacements(json_file, toml_deps):
    """Gets a dictionary of all dependency replacements to be made."""
    replacements = {}
    with open(json_file, 'r') as f:
        json_data = json.loads(f.read())

        outdated_deps = json_data['outdated']['dependencies']
        for dep in outdated_deps:
            group = dep['group']
            name = dep['name']

            curr_version = dep['version']
            new_version = dep['available']['release']

            # For dependencies and classhpaths
            curr_dep = f"{group}:{name}:{curr_version}"
            new_dep = f"{group}:{name}:{new_version}"
            replacements[curr_dep] = new_dep

            # For the plugins block in .kts files
            curr_plugin = f'\("{group}"\) version "{curr_version}"'
            new_plugin = f'("{group}") version "{new_version}"'
            replacements[curr_plugin] = new_plugin

            # For the TOML dependencies
            module = group + ':' + name
            if module not in toml_deps:
                continue
            curr_dep = toml_deps[module]
            if 'original_line' in curr_dep:
                original_line = curr_dep['original_line']
                new_line = original_line.replace(curr_version, new_version)
                replacements[original_line] = new_line

    return replacements


def update_project(project_path, toml_path):
    """Runs through all build configuration files and performs replacements for individual android project."""
    replacements = {}
    replacements.update(get_android_replacements())
    # Open the Gradle Version Catalog file and fetch its dependencies
    toml_dependencies = get_toml_dependencies(toml_path)
    replacements.update(get_dep_replacements(project_path, toml_dependencies))

    # Print all updates found
    print("Dependency updates:")
    for (k, v) in iter(replacements.items()):
        print(f"{k} --> {v}")

    # Iterate through each file and replace it
    for config_file in find_configuration_files():
        print(f"Updating dependencies for: {config_file}")

        new_data = ''
        with open(config_file, 'r') as f:
            # Perform each replacement
            new_data = f.read()
            for (k, v) in iter(replacements.items()):
                new_data = re.sub(k, v, new_data)

        # Write the file
        with open(config_file, 'w') as f:
            f.write(new_data)


def update_all():
    """Runs through all build configuration files and performs replacements."""

    project_root = os.getcwd()
    print(f"Repo root: {project_root}")

    top_level_report = os.path.join(project_root, RELATIVE_PATH_TO_JSON_REPORT)
    toml_path = os.path.join(project_root, RELATIVE_PATH_TO_TOML)

    if os.path.exists(top_level_report):
        print("Update dependencies via top-level report")
        update_project(top_level_report, toml_path)
    else:
        print("Update dependencies via child-level report(s)")
        first_level_subdirectories = get_immediate_subdirectories(project_root)
        print(f"List of subdirectories: {first_level_subdirectories}")

        for subdirectory in first_level_subdirectories:
            print(f"subdirectory: {subdirectory}")
            subdirectory_report = os.path.join(project_root, subdirectory, RELATIVE_PATH_TO_JSON_REPORT)
            toml_path = os.path.join(project_root, subdirectory, RELATIVE_PATH_TO_TOML)

            if os.path.exists(subdirectory_report):
                print("\tUpdate dependencies in subdirectory")
                update_project(subdirectory_report, toml_path)
            else:
                print("\tNo report in subdirectory")


def get_toml_dependency(line, versions):
    original_line = line
    # skip dependencies that don't specify a version
    if 'version' not in line:
        return {}
    # Turn it into a valid JSON
    line = re.sub(DEPENDENCY_RE, r'"\1" =', line)
    value = line.split("=", 1)[1].replace("=", ":")
    dep_json = json.loads(value)
    # unspecified version means it's an internal dependency
    # we can skip version bumps for those
    if 'version' in dep_json and dep_json['version'] == 'unspecified':
        return {}
    # Fill in the group and name
    if 'module' in dep_json:
        module = dep_json.pop('module')
        [group, name] = module.split(':')
        dep_json.update({'group': group, 'name': name})
    if 'id' in dep_json:
        # 'id' indicates this is a plugin
        dep_json['group'] = dep_json.pop('id')
        dep_json['name'] = dep_json['group'] + '.gradle.plugin'

    # Fill in the current version
    if 'version.ref' in dep_json:
        dep_json['original_line'] = versions[dep_json.pop('version.ref')]['original_line']
    # if the version is inlined
    if 'version' in dep_json:
        dep_json['original_line'] = original_line
    key = dep_json.pop('group') + ':' + dep_json.pop('name')
    return {key: dep_json}


def get_toml_dependencies(toml_file):
    """Gets a dictionary of all TOML dependencies."""
    # This code assumes the [versions] block will always be first
    # True = read [versions] block; False = read [libraries] or [plugins] block
    reading_versions = True
    versions = {}
    deps = {}
    try:
        with open(toml_file, 'r') as f:
            lines = f.readlines()
            for line in lines:
                # skip empty lines or comments
                if line.strip() == '' or line.startswith("#"):
                    continue
                if '[versions]' in line:
                    reading_versions = True
                    continue
                if '[libraries]' in line or '[plugins]' in line:
                    reading_versions = False
                    continue
                # Versions
                if reading_versions:
                    version_match = re.search(VERSION_RE, line)
                    if version_match:
                        key = version_match.group(1).strip()
                        value = version_match.group(2)
                        versions[key] = {'curr_version': value, 'original_line': line}
                # Libraries and Plugins
                else:
                    deps.update(get_toml_dependency(line, versions))
    except FileNotFoundError:
        print('This project does not contain a ' + RELATIVE_PATH_TO_TOML + ' file.')
    return deps


def get_immediate_subdirectories(directory):
    return [name for name in os.listdir(directory)
            if os.path.isdir(os.path.join(directory, name)) and not name.startswith('.')]


if __name__ == '__main__':
    update_all()