rclnodejs 1.8.2 → 1.9.0-alpha.0

package/rosidl_gen/packages.js

@@ -150,9 +150,7 @@ async function generateMsgForSrv(filePath, interfaceInfo, pkgMap) {
   const arr = data.split(/-{3,}/);
   if (arr.length == 2) {
     const packagePath = path.join(serviceMsgPath, interfaceInfo.pkgName);
-    if (!fs.existsSync(packagePath)) {
-      fs.mkdirSync(packagePath);
-    }
+    fs.mkdirSync(packagePath, { recursive: true });
 
     await fsp.writeFile(path.join(packagePath, requestMsgName), arr[0]);
     await fsp.writeFile(path.join(packagePath, responseMsgName), arr[1]);

package/rosidl_gen/primitive_types.js

@@ -26,14 +26,14 @@ const StringRefStruct = StructType({
 
 function initString(str, own = false) {
   if (own) {
-    if ((!str) instanceof Buffer) {
+    if (!(str instanceof Buffer)) {
       throw new TypeError(
         'Invalid argument: should provide a Node Buffer to bindingsStringInit()'
       );
     }
     rclnodejs.initString(str);
   } else {
-    if ((!str) instanceof StringRefStruct) {
+    if (!(str instanceof StringRefStruct)) {
       throw new TypeError(
         'Invalid argument: should provide a type of StringRefStruct'
       );

package/rosidl_parser/idl_parser.py

@@ -0,0 +1,437 @@
+# Copyright (c) 2025, The Robot Web Tools Contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+IDL file parser that uses rosidl_parser to directly parse .idl files and
+produce the same JSON spec format as parser.py does for .msg files.
+
+This eliminates the need for the intermediate .idl -> .msg conversion step.
+"""
+
+import sys
+import json
+
+from rosidl_parser.parser import parse_idl_string
+from rosidl_parser.definition import (
+    AbstractNestedType,
+    Action,
+    Array,
+    BasicType,
+    BoundedSequence,
+    BoundedString,
+    BoundedWString,
+    Message,
+    NamedType,
+    NamespacedType,
+    Service,
+    UnboundedSequence,
+    UnboundedString,
+    UnboundedWString,
+)
+
+# Mapping from IDL basic type names to ROS2 message type names
+IDL_TYPE_TO_ROS2 = {
+    'boolean': 'bool',
+    'octet': 'byte',
+    'char': 'char',
+    'wchar': 'wchar',
+    'int8': 'int8',
+    'uint8': 'uint8',
+    'int16': 'int16',
+    'uint16': 'uint16',
+    'int32': 'int32',
+    'uint32': 'uint32',
+    'int64': 'int64',
+    'uint64': 'uint64',
+    'float': 'float32',
+    'double': 'float64',
+    'long double': 'float64',
+    'short': 'int16',
+    'long': 'int32',
+    'long long': 'int64',
+    'unsigned short': 'uint16',
+    'unsigned long': 'uint32',
+    'unsigned long long': 'uint64',
+}
+
+
+def _map_basic_type(typename):
+    """Map an IDL basic type name to its ROS2 equivalent."""
+    return IDL_TYPE_TO_ROS2.get(typename, typename)
+
+
+def _get_nestable_type_info(type_obj):
+    """
+    Extract type info from a nestable type (the inner type for arrays/sequences,
+    or the type itself for non-nested types).
+
+    Returns a dict with: pkgName, type, stringUpperBound, isPrimitiveType
+    """
+    if isinstance(type_obj, BasicType):
+        ros2_type = _map_basic_type(type_obj.typename)
+        return {
+            'pkgName': None,
+            'type': ros2_type,
+            'stringUpperBound': None,
+            'isPrimitiveType': True,
+        }
+    elif isinstance(type_obj, (UnboundedString, BoundedString)):
+        string_upper_bound = None
+        if isinstance(type_obj, BoundedString):
+            string_upper_bound = type_obj.maximum_size
+        return {
+            'pkgName': None,
+            'type': 'string',
+            'stringUpperBound': string_upper_bound,
+            'isPrimitiveType': True,
+        }
+    elif isinstance(type_obj, (UnboundedWString, BoundedWString)):
+        string_upper_bound = None
+        if isinstance(type_obj, BoundedWString):
+            string_upper_bound = type_obj.maximum_size
+        return {
+            'pkgName': None,
+            'type': 'wstring',
+            'stringUpperBound': string_upper_bound,
+            'isPrimitiveType': True,
+        }
+    elif isinstance(type_obj, NamespacedType):
+        # Convert Token objects to plain strings if needed
+        namespaces = [str(ns) for ns in type_obj.namespaces]
+        pkg_name = namespaces[0] if namespaces else None
+        return {
+            'pkgName': pkg_name,
+            'type': str(type_obj.name),
+            'stringUpperBound': None,
+            'isPrimitiveType': False,
+        }
+    elif isinstance(type_obj, NamedType):
+        # NamedType is typically resolved by typedefs, but handle it just in case
+        return {
+            'pkgName': None,
+            'type': str(type_obj.name),
+            'stringUpperBound': None,
+            'isPrimitiveType': False,
+        }
+    else:
+        raise ValueError(f'Unexpected nestable type: {type(type_obj).__name__}')
+
+
+def _get_type_json(member_type):
+    """
+    Convert a rosidl_parser type object to the JSON format expected by
+    the rclnodejs templates.
+
+    Returns a dict matching the spec.fields[].type format:
+    {isArray, arraySize, isUpperBound, isDynamicArray, isFixedSizeArray,
+     pkgName, type, stringUpperBound, isPrimitiveType}
+    """
+    if isinstance(member_type, Array):
+        # Fixed-size array: e.g., float64[9]
+        inner_info = _get_nestable_type_info(member_type.value_type)
+        return {
+            'isArray': True,
+            'arraySize': member_type.size,
+            'isUpperBound': False,
+            'isDynamicArray': False,
+            'isFixedSizeArray': True,
+            **inner_info,
+        }
+    elif isinstance(member_type, BoundedSequence):
+        # Bounded dynamic array: e.g., sequence<float64, 3>
+        inner_info = _get_nestable_type_info(member_type.value_type)
+        return {
+            'isArray': True,
+            'arraySize': member_type.maximum_size,
+            'isUpperBound': True,
+            'isDynamicArray': True,
+            'isFixedSizeArray': False,
+            **inner_info,
+        }
+    elif isinstance(member_type, UnboundedSequence):
+        # Unbounded dynamic array: e.g., sequence<float64>
+        inner_info = _get_nestable_type_info(member_type.value_type)
+        return {
+            'isArray': True,
+            'arraySize': None,
+            'isUpperBound': False,
+            'isDynamicArray': True,
+            'isFixedSizeArray': False,
+            **inner_info,
+        }
+    else:
+        # Non-array/sequence type
+        inner_info = _get_nestable_type_info(member_type)
+        return {
+            'isArray': False,
+            'arraySize': None,
+            'isUpperBound': False,
+            'isDynamicArray': False,
+            'isFixedSizeArray': False,
+            **inner_info,
+        }
+
+
+def _get_default_value(member):
+    """Extract default value from member annotations.
+
+    rosidl_parser returns array/sequence defaults as tuple-like strings,
+    e.g., "(0, 127, -128)" or "('', 'max value', 'min value')".
+    The .msg parser returns these as Python lists [0, 127, -128].
+    We need to convert the tuple-strings to proper lists.
+    """
+    try:
+        default_annotation = member.get_annotation_value('default')
+        if isinstance(default_annotation, dict) and 'value' in default_annotation:
+            value = default_annotation['value']
+        else:
+            value = default_annotation
+
+        # If the value is a string that looks like a tuple "(a, b, c)",
+        # parse it into a Python list
+        if isinstance(value, str) and value.startswith('(') and value.endswith(')'):
+            value = _parse_tuple_string(value, member)
+
+        return value
+    except ValueError:
+        return None
+
+
+def _parse_tuple_string(s, member):
+    """
+    Parse a tuple-like string from rosidl_parser into a proper Python list.
+
+    Handles formats like:
+      "(0, 127, -128)" -> [0, 127, -128]
+      "(1.125, 0.0, -1.125)" -> [1.125, 0.0, -1.125]
+      "(False, True, False)" -> [False, True, False]
+      "('', 'max value', 'min value')" -> ['', 'max value', 'min value']
+    """
+    inner = s[1:-1]  # Strip outer parentheses
+
+    # Determine the element type from the member's type
+    member_type = member.type
+    if isinstance(member_type, AbstractNestedType):
+        element_type = member_type.value_type
+    else:
+        element_type = member_type
+
+    # Parse string arrays specially (may contain commas in values)
+    if isinstance(element_type, (UnboundedString, BoundedString,
+                                  UnboundedWString, BoundedWString)):
+        return _parse_string_tuple(inner)
+
+    # For boolean arrays
+    if isinstance(element_type, BasicType) and element_type.typename == 'boolean':
+        parts = [p.strip() for p in inner.split(',')]
+        return [p == 'True' for p in parts]
+
+    # For numeric arrays  
+    parts = [p.strip() for p in inner.split(',')]
+    result = []
+    for part in parts:
+        if not part:
+            continue
+        # Try int first, then float
+        try:
+            result.append(int(part))
+        except ValueError:
+            try:
+                result.append(float(part))
+            except ValueError:
+                result.append(part)
+    return result
+
+
+def _parse_string_tuple(inner):
+    """Parse the inside of a tuple containing quoted strings.
+
+    e.g., "'', 'max value', 'min value'" -> ['', 'max value', 'min value']
+    """
+    result = []
+    i = 0
+    while i < len(inner):
+        if inner[i] == "'":
+            # Find matching closing quote
+            j = i + 1
+            while j < len(inner):
+                if inner[j] == "'":
+                    result.append(inner[i + 1:j])
+                    i = j + 1
+                    break
+                j += 1
+            else:
+                break
+        elif inner[i] == '"':
+            j = i + 1
+            while j < len(inner):
+                if inner[j] == '"':
+                    result.append(inner[i + 1:j])
+                    i = j + 1
+                    break
+                j += 1
+            else:
+                break
+        else:
+            i += 1
+    return result
+
+
+def _get_constant_type_str(constant):
+    """Get the ROS2 type string for a constant."""
+    if isinstance(constant.type, BasicType):
+        return _map_basic_type(constant.type.typename)
+    elif isinstance(constant.type, (UnboundedString, BoundedString)):
+        return 'string'
+    elif isinstance(constant.type, (UnboundedWString, BoundedWString)):
+        return 'wstring'
+    return str(constant.type)
+
+
+def get_json_from_message(msg, pkg_name=None):
+    """
+    Convert a rosidl_parser Message object to JSON spec matching
+    what parser.py produces for .msg files.
+    """
+    namespaced_type = msg.structure.namespaced_type
+    namespaces = [str(ns) for ns in namespaced_type.namespaces]
+    msg_name = str(namespaced_type.name)
+
+    if pkg_name is None:
+        pkg_name = namespaces[0] if namespaces else ''
+
+    # Build fields
+    fields = []
+    for member in msg.structure.members:
+        field = {
+            'name': member.name,
+            'type': _get_type_json(member.type),
+            'default_value': _get_default_value(member),
+        }
+        fields.append(field)
+
+    # Build constants
+    constants = []
+    for constant in msg.constants:
+        constants.append({
+            'type': _get_constant_type_str(constant),
+            'name': constant.name,
+            'value': constant.value,
+        })
+
+    return {
+        'constants': constants,
+        'fields': fields,
+        'baseType': {
+            'pkgName': pkg_name,
+            'type': msg_name,
+            'stringUpperBound': None,
+            'isPrimitiveType': False,
+        },
+        'msgName': msg_name,
+    }
+
+
+def get_json_from_service(srv):
+    """
+    Convert a rosidl_parser Service object to JSON spec matching
+    what parser.py produces for .srv files.
+    """
+    namespaces = [str(ns) for ns in srv.namespaced_type.namespaces]
+    pkg_name = namespaces[0] if namespaces else ''
+    srv_name = str(srv.namespaced_type.name)
+
+    return {
+        'pkgName': pkg_name,
+        'srvName': srv_name,
+        'request': get_json_from_message(srv.request_message, pkg_name),
+        'response': get_json_from_message(srv.response_message, pkg_name),
+    }
+
+
+def get_json_from_action(action):
+    """
+    Convert a rosidl_parser Action object to JSON spec matching
+    what parser.py produces for .action files.
+    """
+    namespaces = [str(ns) for ns in action.namespaced_type.namespaces]
+    pkg_name = namespaces[0] if namespaces else ''
+    action_name = str(action.namespaced_type.name)
+
+    return {
+        'pkgName': pkg_name,
+        'actionName': action_name,
+        'goal': get_json_from_message(action.goal, pkg_name),
+        'result': get_json_from_message(action.result, pkg_name),
+        'feedback': get_json_from_message(action.feedback, pkg_name),
+    }
+
+
+def parse_idl_file(idl_file_path):
+    """
+    Parse an .idl file and return a JSON object in the same format
+    as parser.py produces.
+
+    The return value depends on the interface type:
+    - Message: same format as parse_message_file
+    - Service: same format as parse_service_file
+    - Action: same format as parse_action_file
+
+    Returns a dict with 'type' indicating the interface kind and 'spec'
+    containing the JSON spec.
+    """
+    with open(idl_file_path, 'r') as f:
+        content_str = f.read()
+
+    content = parse_idl_string(content_str)
+
+    # Find the main element (Message, Service, or Action)
+    messages = content.get_elements_of_type(Message)
+    services = content.get_elements_of_type(Service)
+    actions = content.get_elements_of_type(Action)
+
+    if actions:
+        action = actions[0]
+        return {
+            'type': 'action',
+            'spec': get_json_from_action(action),
+        }
+    elif services:
+        service = services[0]
+        return {
+            'type': 'service',
+            'spec': get_json_from_service(service),
+        }
+    elif messages:
+        message = messages[0]
+        return {
+            'type': 'message',
+            'spec': get_json_from_message(message),
+        }
+    else:
+        raise ValueError(f'No Message, Service, or Action found in {idl_file_path}')
+
+
+if __name__ == '__main__':
+    if len(sys.argv) < 2:
+        print('Usage: idl_parser.py <idl_file_path>', file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        result = parse_idl_file(sys.argv[1])
+        print(json.dumps(result))
+        sys.exit(0)
+    except Exception as e:
+        print(str(e), file=sys.stderr)
+        sys.exit(1)

package/rosidl_parser/parser.py

@@ -15,7 +15,6 @@
 import sys
 import json
 
-import rosidl_parser
 from rosidl_adapter import parser
 
 def get_json_object_from_base_type_object(base_type_obj):
@@ -41,15 +40,14 @@ def get_json_object_from_msg_spec_object(msg_spec_object):
     for constant in msg_spec_object.constants:
         constants.append({'type': constant.type, 'name': constant.name, 'value': constant.value})
 
-    msg_name = {'msgName': msg_spec_object.msg_name}
     json_obj = {'constants': constants, 'fields': fields, 'baseType': get_json_object_from_base_type_object(msg_spec_object.base_type),
         'msgName': msg_spec_object.msg_name}
 
     return json_obj
 
 if __name__ == '__main__':
-    if len(sys.argv) < 3:
-        print('Wrong number of argments')
+    if len(sys.argv) < 4:
+        print('Usage: {} <command> <packageName> <filePath>'.format(sys.argv[0]), file=sys.stderr)
         sys.exit(1)
     try:
         parser_method = getattr(parser, sys.argv[1])

package/rosidl_parser/rosidl_parser.js

@@ -41,6 +41,33 @@ const rosidlParser = {
     return this._parseFile('parse_action_file', packageName, filePath);
   },
 
+  /**
+   * Parse an .idl file directly using rosidl_parser (no .msg conversion needed).
+   * Returns an object with { type: 'message'|'service'|'action', spec: ... }
+   * where spec matches the same format as parseMessageFile/parseServiceFile/parseActionFile.
+   */
+  parseIdlFile(filePath) {
+    return new Promise((resolve, reject) => {
+      const args = [path.join(__dirname, 'idl_parser.py'), filePath];
+      const [pythonExecutableFile, pythonExecutableArgs] = pythonExecutable;
+      execFile(
+        pythonExecutableFile,
+        pythonExecutableArgs.concat(args),
+        (err, stdout, stderr) => {
+          if (err) {
+            reject(
+              new Error(
+                `There was an error parsing IDL file "${filePath}": "${err}"; stderr was: ${stderr}`
+              )
+            );
+          } else {
+            resolve(this._parseJSONObject(stdout));
+          }
+        }
+      );
+    });
+  },
+
   _parseJSONObject(str) {
     // For nodejs >= `contextSupportedVersion`, we leverage context parameter to
     // convert unsafe integer to string, otherwise, json-bigint is used.

package/scripts/run_asan_test.sh

@@ -0,0 +1,118 @@
+#!/bin/bash
+# Run tests with AddressSanitizer (ASan/LSan) to detect memory leaks and errors
+# in the native N-API addon.
+#
+# Requires: ROS2 sourced, g++ with libasan
+#
+# Usage:
+#   bash scripts/run_asan_test.sh                        # rebuild + run all tests
+#   bash scripts/run_asan_test.sh test/test-node.js      # rebuild + run specific test(s)
+#   bash scripts/run_asan_test.sh --no-build test/test-node.js  # skip rebuild
+#   bash scripts/run_asan_test.sh --exclude test/test-serialization.js  # exclude specific test(s)
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+cd "$PROJECT_DIR"
+
+# Parse flags
+DO_BUILD=1
+ARGS=()
+EXCLUDES=()
+NEXT_IS_EXCLUDE=0
+for arg in "$@"; do
+  if [[ $NEXT_IS_EXCLUDE -eq 1 ]]; then
+    EXCLUDES+=("$arg")
+    NEXT_IS_EXCLUDE=0
+  elif [[ "$arg" == "--no-build" ]]; then
+    DO_BUILD=0
+  elif [[ "$arg" == "--exclude" ]]; then
+    NEXT_IS_EXCLUDE=1
+  else
+    ARGS+=("$arg")
+  fi
+done
+
+if [[ $NEXT_IS_EXCLUDE -eq 1 ]]; then
+  echo "Error: --exclude requires a test file argument"
+  echo "Usage: bash scripts/run_asan_test.sh --exclude test/test-foo.js"
+  exit 1
+fi
+
+# Step 1: Build with ASan
+if [[ $DO_BUILD -eq 1 ]]; then
+  echo "=== Building with AddressSanitizer ==="
+  CXXFLAGS="-fsanitize=address" npx node-gyp -j 16 rebuild --debug
+fi
+
+# Step 2: Locate libasan
+LIBASAN=$(g++ -print-file-name=libasan.so)
+if [[ "$LIBASAN" == "libasan.so" ]]; then
+  # g++ returned just the name, try to find the full path
+  LIBASAN=$(find /usr/lib* -name "libasan.so*" -type f 2>/dev/null | head -1)
+fi
+
+if [[ -z "$LIBASAN" || ! -f "$LIBASAN" ]]; then
+  echo "Warning: Could not find libasan.so, proceeding without LD_PRELOAD"
+  echo "If you see 'ASan not the first DSO' errors, install libasan: sudo apt install libasan6"
+  LIBASAN=""
+fi
+
+# Step 3: Set up environment
+export LSAN_OPTIONS="suppressions=$PROJECT_DIR/suppr.txt"
+if [[ -n "$LIBASAN" ]]; then
+  export LD_PRELOAD="$LIBASAN"
+fi
+
+# Step 3.5: Temporarily hide prebuilds so the debug build is loaded
+PREBUILDS_DIR="$PROJECT_DIR/prebuilds"
+PREBUILDS_BAK="$PROJECT_DIR/.prebuilds_asan_bak"
+MOVED_PREBUILDS=0
+if [[ -d "$PREBUILDS_DIR" ]]; then
+  if [[ -d "$PREBUILDS_BAK" ]]; then
+    echo "Error: $PREBUILDS_BAK already exists (previous interrupted run?)."
+    echo "Please remove it manually and retry: rm -rf $PREBUILDS_BAK"
+    exit 1
+  fi
+  mv "$PREBUILDS_DIR" "$PREBUILDS_BAK"
+  MOVED_PREBUILDS=1
+fi
+
+# Restore prebuilds on exit (even on failure)
+cleanup() {
+  if [[ $MOVED_PREBUILDS -eq 1 && -d "$PREBUILDS_BAK" ]]; then
+    mv "$PREBUILDS_BAK" "$PREBUILDS_DIR"
+  fi
+}
+trap cleanup EXIT
+
+# Step 4: Build mocha exclude args from --exclude flags, blocklist.json, and asan_blocklist.json
+MOCHA_EXCLUDES=()
+for exc in "${EXCLUDES[@]}"; do
+  MOCHA_EXCLUDES+=(--ignore "$exc")
+done
+
+# Auto-exclude tests from blocklist.json (Linux entries) and asan_blocklist.json
+for blocklist in "$PROJECT_DIR/test/blocklist.json" "$PROJECT_DIR/test/asan_blocklist.json"; do
+  if [[ -f "$blocklist" ]]; then
+    while IFS= read -r test_file; do
+      MOCHA_EXCLUDES+=(--ignore "test/$test_file")
+    done < <(node -e "
+      const bl = require('$blocklist');
+      const entries = bl.Linux || bl;
+      if (Array.isArray(entries)) entries.forEach(t => console.log(t));
+    " 2>/dev/null)
+  fi
+done
+
+# Step 5: Run tests
+if [[ ${#ARGS[@]} -gt 0 ]]; then
+  echo "=== Running ASan test: ${ARGS[*]} ==="
+  node --expose-gc node_modules/.bin/mocha -r test/gc-on-exit.js "${MOCHA_EXCLUDES[@]}" "${ARGS[@]}"
+else
+  echo "=== Running all ASan tests ==="
+  node --expose-gc node_modules/.bin/mocha -r test/gc-on-exit.js "${MOCHA_EXCLUDES[@]}" 'test/test-*.js'
+fi
+
+echo "=== ASan test complete ==="