Add ros_xacro support

Author: julianadrianheine

bazel_ros2_rules/lib/private/repos.bzl

@@ -5,6 +5,7 @@ COMMON_FILES_MANIFEST = [
     "ros_cc.bzl",
     "ros_py.bzl",
     "rosidl.bzl",
+    "xacro.bzl",
     "cmake_tools/__init__.py",
     "cmake_tools/file_api.py",
     "cmake_tools/packages.py",

bazel_ros2_rules/lib/private/xacro.bzl

@@ -0,0 +1,161 @@
+""" Defines a rule and macro for transforming xacro files to a URDF.
+"""
+
+load("@bazel_ros2_rules//lib:ament_index.bzl", "ament_index_share_files")
+load(":distro.bzl", "REPOSITORY_ROOT")
+load(":ros_py.bzl", "ros_py_binary")
+
+# Derive the plain workspace name from the label-format REPOSITORY_ROOT.
+# REPOSITORY_ROOT = "@@name//" (Bzlmod) or "@name//" (WORKSPACE mode).
+# Runfiles Rlocation paths use just the workspace name: "name/target".
+_WORKSPACE_NAME = REPOSITORY_ROOT.lstrip("@").rstrip("/")
+
+def _xacro_generate_file_impl(ctx):
+    out = ctx.actions.declare_file(ctx.label.name)
+    ctx.actions.write(out, ctx.attr.content, is_executable = True)
+    return [DefaultInfo(
+        files = depset([out]),
+        data_runfiles = ctx.runfiles(files = [out]),
+    )]
+
+_xacro_generate_file = rule(
+    attrs = {"content": attr.string(mandatory = True)},
+    output_to_genfiles = True,
+    implementation = _xacro_generate_file_impl,
+)
+
+# Runner script template.  The outer dload shim (from ros_py_binary) has
+# already set AMENT_PREFIX_PATH to include both system and user-package
+# prefixes (all absolute via $RUNFILES_DIR) before this script runs.  What is
+# needed then, is to locate and exec the inner @ros2//:xacro shim.
+_XACRO_RUNNER_TEMPLATE = """\
+import os
+import sys
+
+from python.runfiles import runfiles as runfiles_api
+
+assert __name__ == "__main__"
+runfiles = runfiles_api.Create()
+xacro_bin = runfiles.Rlocation("{xacro_rlocation}")
+os.execv(xacro_bin, [xacro_bin] + sys.argv[1:])
+"""
+
+def _ros_xacro_impl(ctx):
+    output = ctx.actions.declare_file(ctx.attr.name + ".urdf")
+    args = ctx.actions.args()
+    args.add(ctx.file.src)
+    args.add("-o", output)
+    args.add_all(ctx.attr.xacro_args)
+    ctx.actions.run(
+        inputs = [ctx.file.src] + ctx.files.data,
+        outputs = [output],
+        executable = ctx.executable.xacro_tool,
+        arguments = [args],
+    )
+    return [DefaultInfo(files = depset([output]))]
+
+_ros_xacro_rule = rule(
+    attrs = {
+        "src": attr.label(
+            allow_single_file = [".xacro"],
+            mandatory = True,
+            doc = "The main .urdf.xacro file to process.",
+        ),
+        "data": attr.label_list(
+            allow_files = [".xacro"],
+            default = [],
+            doc = "Additional .xacro files included via relative paths.",
+        ),
+        "xacro_args": attr.string_list(
+            default = [],
+            doc = "Extra key:=value arguments forwarded to xacro.",
+        ),
+        "xacro_tool": attr.label(
+            executable = True,
+            cfg = "exec",
+            mandatory = True,
+            doc = "The per-invocation xacro runner binary.",
+        ),
+    },
+    implementation = _ros_xacro_impl,
+)
+
+def ros_xacro(name, src, data = [], ros_packages = {}, xacro_args = [], visibility = None, **kwargs):
+    """Transforms a .urdf.xacro file into a .urdf file.
+
+    User-defined packages are declared inline via the ros_packages dict.  Each
+    entry maps a ROS package name to the list of files to place under
+    share/<package_name>/.  The strip_prefix is derived automatically from the
+    calling BUILD file's package path, so files are placed relative to that
+    package directory.
+
+    The dload shim from ros_py_binary extends AMENT_PREFIX_PATH with all
+    registered package prefixes (absolute, via $RUNFILES_DIR) before xacro
+    runs, making $(find <pkg>) work for both local and system packages.
+
+    Example:
+        ros_xacro(
+            name = "example",
+            src = "robot.urdf.xacro",
+            data = ["base.xacro", "arm.xacro"],
+            ros_packages = {
+                "my_robot": glob(["urdf/**"]),
+            },
+            xacro_args = ["sim:=false"],
+        )
+
+    Args:
+        name:         target name; the output file is named <name>.urdf
+        src:          the .urdf.xacro source file
+        data:         additional .xacro files included via relative paths
+                      (i.e. plain <xacro:include filename="other.xacro"/>);
+                      must be listed here so Bazel sandboxes them and tracks
+                      them as dependencies for incremental rebuilds
+        ros_packages: dict mapping ROS package name to list of share files;
+                      files are stripped of the calling package's path prefix
+                      automatically before being placed under share/<pkg>/
+        xacro_args:   list of key:=value arguments forwarded to xacro
+        visibility:   target visibility
+    """
+    pkg_targets = []
+    strip_prefix = native.package_name() + "/" if native.package_name() else ""
+    for pkg_name, srcs in ros_packages.items():
+        index_name = "_{}_pkg_{}".format(name, pkg_name)
+        ament_index_share_files(
+            name = index_name,
+            package_name = pkg_name,
+            srcs = srcs,
+            strip_prefix = strip_prefix,
+            visibility = ["//visibility:private"],
+        )
+        pkg_targets.append(":" + index_name)
+
+    runner_data = [REPOSITORY_ROOT + ":xacro"] + pkg_targets
+
+    runner_main = "_{}_runner_main.py".format(name)
+    _xacro_generate_file(
+        name = runner_main,
+        content = _XACRO_RUNNER_TEMPLATE.format(
+            xacro_rlocation = _WORKSPACE_NAME + "/xacro",
+        ),
+        visibility = ["//visibility:private"],
+    )
+
+    runner_name = "_{}_runner".format(name)
+    ros_py_binary(
+        name = runner_name,
+        main = runner_main,
+        srcs = [runner_main],
+        data = runner_data,
+        deps = ["@bazel_ros2_rules//deps/python/runfiles"],
+        visibility = ["//visibility:private"],
+    )
+
+    _ros_xacro_rule(
+        name = name,
+        src = src,
+        data = data,
+        xacro_args = xacro_args,
+        xacro_tool = ":" + runner_name,
+        visibility = visibility,
+    )

ros2_example_bazel_installed/MODULE.bazel

@@ -17,9 +17,11 @@ ROS_REQUIRED_PACKAGES = [
     "rclcpp_action",
     "rclpy",
     "rosbag2",
+    "realsense2_description",
     "ros2bag_mcap_cli",
     "ros2bag_sqlite3_cli",
     "tf2_py",
+    "xacro",
 ] + [
     # These are possible RMW implementations. Uncomment one and only one to
     # change implementations

ros2_example_bazel_installed/ros2_example_xacro/BUILD.bazel

@@ -0,0 +1,20 @@
+load("@ros2//:ros_py.bzl", "ros_py_test")
+load("@ros2//:xacro.bzl", "ros_xacro")
+
+ros_xacro(
+    name = "example",
+    src = "example.urdf.xacro",
+    data = ["snippet.xacro"],
+    ros_packages = {
+        "my_robot": glob(["urdf/**"]),
+    },
+    xacro_args = ["sim:=false"],
+)
+
+ros_py_test(
+    name = "xacro_test",
+    srcs = ["test/xacro_test.py"],
+    data = [":example"],
+    main = "test/xacro_test.py",
+    deps = ["@rules_python//python/runfiles"],
+)

ros2_example_bazel_installed/ros2_example_xacro/example.urdf.xacro

@@ -0,0 +1,13 @@
+<!-- urdf/robot.urdf.xacro -->
+<robot xmlns:xacro="http://www.ros.org/wiki/xacro">
+  <!-- Should be able to include `.xacros` via a relative path (data= attribute) -->
+  <xacro:include filename="snippet.xacro"/>
+  <!-- Should be able to compose with local `.xacros` -->
+  <xacro:include filename="$(find my_robot)/urdf/macros.xacro"/>
+  <!-- Should be able to bring `.xacros` installed in the system (via `realsense2_description` for this example)-->
+  <xacro:include filename="$(find realsense2_description)/urdf/_d435i.urdf.xacro"/>
+   <!-- Should be able to retrieve xacro args-->
+   <xacro:arg name="sim" default="true" />
+   <xacro:property name="sim_mode" value="$(arg sim)"/>
+   <sim>${sim_mode}</sim>
+</robot>

ros2_example_bazel_installed/ros2_example_xacro/snippet.xacro

@@ -0,0 +1,5 @@
+<?xml version="1.0"?>
+<!-- A minimal xacro included via a relative path to test the data= attribute. -->
+<robot xmlns:xacro="http://www.ros.org/wiki/xacro">
+  <link name="snippet_link"/>
+</robot>

ros2_example_bazel_installed/ros2_example_xacro/test/xacro_test.py

@@ -0,0 +1,45 @@
+"""Tests that ros_xacro correctly processes xacro args and includes."""
+
+from python.runfiles import runfiles
+
+
+def _read_urdf():
+    r = runfiles.Create()
+    path = r.Rlocation(
+        "ros2_example_bazel_installed/ros2_example_xacro/example.urdf"
+    )
+    with open(path) as f:
+        return f.read()
+
+
+def test_sim_arg_is_substituted():
+    """The sim xacro arg value appears in the output URDF."""
+    content = _read_urdf()
+    assert "<sim>False</sim>" in content, (
+        "Expected '<sim>False</sim>' in URDF output:\n" + content
+    )
+
+
+def test_local_package_macros_expanded():
+    """Macros from the local my_robot package are resolved and expanded."""
+    content = _read_urdf()
+    # The macros.xacro defines materials; verify they appear in the output.
+    assert "aluminum" in content, (
+        "Expected materials from my_robot/urdf/macros.xacro in output:\n"
+        + content
+    )
+
+
+def test_relative_include_expanded():
+    """A xacro included via a relative path (data=) appears in the output."""
+    content = _read_urdf()
+    assert 'name="snippet_link"' in content, (
+        "Expected snippet_link from snippet.xacro in output:\n" + content
+    )
+
+
+if __name__ == "__main__":
+    test_sim_arg_is_substituted()
+    test_local_package_macros_expanded()
+    test_relative_include_expanded()
+    print("All tests passed.")

ros2_example_bazel_installed/ros2_example_xacro/urdf/macros.xacro

@@ -0,0 +1,6 @@
+<?xml version="1.0"?>
+<robot xmlns:xacro="http://www.ros.org/wiki/xacro">
+  <xacro:macro name="simple_link" params="name">
+    <link name="${name}"/>
+  </xacro:macro>
+</robot>