From 319778383e7edc5d5d19034806ae50190ecfbe34 Mon Sep 17 00:00:00 2001 From: "Addisu Z. Taddese" Date: Fri, 2 Jan 2026 12:07:41 -0600 Subject: [PATCH 1/2] Add scripts for bumping major versions and creating aliases Generated-By: Gemini 2.5 Signed-off-by: Addisu Z. Taddese --- bump_all_aliases.py | 56 +++++++++++++++++++++++++++++ bump_formula_alias.py | 82 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 138 insertions(+) create mode 100755 bump_all_aliases.py create mode 100644 bump_formula_alias.py diff --git a/bump_all_aliases.py b/bump_all_aliases.py new file mode 100755 index 000000000..e9b5e11c2 --- /dev/null +++ b/bump_all_aliases.py @@ -0,0 +1,56 @@ +#!/usr/bin/env python3 + +import subprocess +import sys + +def main(): + """ + Runs the bump_formula_alias.py script for all Gazebo libraries. + """ + libraries_to_bump = [ + "gz-cmake", + "gz-common", + "gz-fuel-tools", + "gz-gui", + "gz-math", + "gz-msgs", + "gz-physics", + "gz-plugin", + "gz-rendering", + "gz-sensors", + "gz-sim", + "gz-tools", + "gz-transport", + "gz-utils", + "sdformat", + ] + + print("--- Starting to create version aliases for all libraries ---") + + for lib in libraries_to_bump: + print(f"Processing library: {lib}") + try: + result = subprocess.run( + ["python3", "bump_formula_alias.py", lib], + capture_output=True, + text=True, + check=True # This will raise an exception for non-zero exit codes + ) + if result.stdout: + print(result.stdout.strip()) + if result.stderr: + print(result.stderr.strip(), file=sys.stderr) + + except subprocess.CalledProcessError as e: + print(f"Error creating alias for {lib}:", file=sys.stderr) + print(e.stdout.strip(), file=sys.stderr) + print(e.stderr.strip(), file=sys.stderr) + except FileNotFoundError: + print("Error: 'python3' command not found. Make sure Python 3 is in your PATH.", file=sys.stderr) + sys.exit(1) + print("-" * 40) + + print("--- Finished creating all version aliases ---") + +if __name__ == '__main__': + main() diff --git a/bump_formula_alias.py b/bump_formula_alias.py new file mode 100644 index 000000000..9dd049582 --- /dev/null +++ b/bump_formula_alias.py @@ -0,0 +1,82 @@ +#!/usr/bin/env python3 + +import argparse +import glob +import os +import re +import sys + +def find_latest_formula(formula_dir, library_name): + """ + Finds the latest version of a formula in the given directory. + Returns a tuple of (latest_version_number, latest_formula_path). + """ + latest_version = -1 + latest_formula_path = None + + # Pattern to match files like `gz-cmake3.rb`, `sdformat12.rb` + search_path = os.path.join(formula_dir, f'{library_name}*.rb') + + for f_path in glob.glob(search_path): + filename = os.path.basename(f_path) + + # Regex to extract version from filenames like 'gz-cmake3.rb' or 'sdformat12.rb' + # It needs to match the library name exactly at the start. + match = re.match(fr'^{re.escape(library_name)}(\d+)\.rb$', filename) + + if match: + version = int(match.group(1)) + if version > latest_version: + latest_version = version + latest_formula_path = f_path + + if latest_version == -1: + return None, None + + return latest_version, latest_formula_path + +def main(): + """Main function""" + parser = argparse.ArgumentParser( + description="Create a version-bumped alias for a Homebrew formula by creating a symlink.") + parser.add_argument('library', help="Versionless name of the library (e.g., 'gz-cmake').") + args = parser.parse_args() + + formula_dir = 'Formula' + library_name = args.library + + latest_version, latest_formula_path = find_latest_formula(formula_dir, library_name) + + if not latest_formula_path: + print(f"Info: Could not find any versioned formulas for '{library_name}'. Skipping.", file=sys.stderr) + sys.exit(0) + + new_version = latest_version + 1 + latest_formula_basename = os.path.basename(latest_formula_path) + + alias_dir = 'Aliases' + if not os.path.isdir(alias_dir): + os.makedirs(alias_dir) + + # Construct the alias name based on the library name + alias_basename = f'{library_name}{new_version}.rb' + alias_path = os.path.join(alias_dir, alias_basename) + + if os.path.exists(alias_path) or os.path.islink(alias_path): + real_target = os.readlink(alias_path) if os.path.islink(alias_path) else '' + expected_target = os.path.join('..', 'Formula', latest_formula_basename) + if os.path.islink(alias_path) and real_target == expected_target: + print(f"Alias '{alias_path}' already exists and points to the latest version. Nothing to do.") + else: + print(f"Warning: Alias '{alias_path}' already exists but does not point to the latest version. Manual intervention required.", file=sys.stderr) + sys.exit(0) + + # Create a relative symlink from the Aliases directory to the Formula directory + symlink_target = os.path.join('..', 'Formula', latest_formula_basename) + print(f"Creating alias for {library_name} version {new_version}...") + os.symlink(symlink_target, alias_path) + + print(f"Successfully created alias: {alias_path} -> {symlink_target}") + +if __name__ == '__main__': + main() From 5633229643b3d9f81a95bbe91a7c347151569901 Mon Sep 17 00:00:00 2001 From: "Addisu Z. Taddese" Date: Fri, 2 Jan 2026 12:17:08 -0600 Subject: [PATCH 2/2] Aliases don't have .rb extension Signed-off-by: Addisu Z. Taddese --- bump_formula_alias.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bump_formula_alias.py b/bump_formula_alias.py index 9dd049582..80ac8524c 100644 --- a/bump_formula_alias.py +++ b/bump_formula_alias.py @@ -59,7 +59,7 @@ def main(): os.makedirs(alias_dir) # Construct the alias name based on the library name - alias_basename = f'{library_name}{new_version}.rb' + alias_basename = f'{library_name}{new_version}' alias_path = os.path.join(alias_dir, alias_basename) if os.path.exists(alias_path) or os.path.islink(alias_path):