Add update verb

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
 - repo: https://github.com/pre-commit/pre-commit-hooks
-  rev: v4.5.0
+  rev: v4.6.0
   hooks:
   - id: check-ast
   - id: check-case-conflict
@@ -29,7 +29,7 @@ repos:
   - id: absolufy-imports
     name: Make python imports absolute
 - repo: https://github.com/psf/black
-  rev: 24.3.0
+  rev: 24.4.2
   hooks:
   - id: black
     name: Python formatting (black)
@@ -45,7 +45,7 @@ repos:
     name: Sorting python imports
     args: [--profile, black]
 - repo: https://github.com/asottile/pyupgrade
-  rev: v3.15.1
+  rev: v3.15.2
   hooks:
   - id: pyupgrade
     name: Upgrade common mistakes
@@ -62,20 +62,20 @@ repos:
     - flake8-simplify
     - pep8-naming
 - repo: https://github.com/astral-sh/ruff-pre-commit
-  rev: v0.3.3
+  rev: v0.4.2
   hooks:
   - id: ruff
     name: Linting Python code (ruff)
     args: [--fix, --exit-non-zero-on-fix]
 - repo: https://github.com/macisamuele/language-formatters-pre-commit-hooks
-  rev: v2.12.0
+  rev: v2.13.0
   hooks:
   - id: pretty-format-yaml
     args: [--autofix, --indent, '2']
   - id: pretty-format-toml
     args: [--autofix]
 - repo: https://github.com/pre-commit/mirrors-mypy
-  rev: v1.9.0
+  rev: v1.10.0
   hooks:
   - id: mypy
     name: Static typechecking (mypy)

package.xml

@@ -1,9 +1,9 @@
 <?xml version="1.0"?>
-<package format="2">
+<package format="3">
   <name>ros2autodoc</name>
-  <version>1.0.0</version>
+  <version>1.2.0</version>
   <description>
-    The ROS2 autodoc project provides a CLI command to automatically generate documentation for ROS2 nodes in markdown syntax.
+    The ROS2 autodoc project provides a CLI command to automatically generate ROS-Wiki-style documentation template nodes in markdown syntax.
   </description>
   <maintainer email="[email protected]">Mohamed Abdelaziz</maintainer>
   <license>BSD-3-Clause</license>
@@ -13,4 +13,4 @@
   <export>
     <build_type>ament_python</build_type>
   </export>
-</package>
+</package>

ros2autodoc/api/__init__.py

@@ -2,26 +2,16 @@
 import sys
 
 # ROS2 node API
-from ros2node.api import (
-    INFO_NONUNIQUE_WARNING_TEMPLATE,
-    get_action_server_info,
-    get_node_names,
-    get_publisher_info,
-    get_service_server_info,
-    get_subscriber_info,
-)
-
-# ROS2 param API
-from ros2param.api import (
-    call_describe_parameters,
-    call_list_parameters,
-    get_parameter_type_string,
-)
+from ros2node.api import INFO_NONUNIQUE_WARNING_TEMPLATE, get_node_names
 
 # ROS2 pkg API
 from ros2pkg.api import get_executable_paths, get_package_names
 
+from ros2autodoc.api.doc_parser import DocParser
 from ros2autodoc.api.doc_writer import DocWriter
+from ros2autodoc.api.node_interface_collector import NodeInterfaceCollector
+
+TODO = "TODO: description"
 
 
 def check_for_package(package_name):
@@ -61,42 +51,50 @@ def get_nodes(package_name):
 
 def document_node(node, package_name, node_name, path, file_name="/README.md"):
     """Document the given node."""
-    writer = DocWriter(package_name, node_name)
-    param_names, params, description = _get_parameters(node, node_name)
-    if len(params) > 0:
-        writer.get_parameters(param_names, params, description)
-    subscribers = get_subscriber_info(
-        node=node, remote_node_name=node_name, include_hidden=False
-    )
-    if len(subscribers) > 0:
-        writer.get_subscribers(subscribers)
-    publishers = get_publisher_info(
-        node=node, remote_node_name=node_name, include_hidden=False
-    )
-    if len(publishers) > 0:
-        writer.get_publishers(publishers)
-    service_servers = get_service_server_info(
-        node=node, remote_node_name=node_name, include_hidden=False
-    )
-    if len(service_servers) > 0:
-        writer.get_service_servers(service_servers)
-    actions_servers = get_action_server_info(
-        node=node, remote_node_name=node_name, include_hidden=False
-    )
-    if len(actions_servers) > 0:
-        writer.get_action_servers(actions_servers)
+    interface_collector = NodeInterfaceCollector(node, node_name)
+    node_interface = interface_collector.get_interfaces()
+    writer = DocWriter(package_name, node_name, node_interface)
     writer.write(path + file_name)
 
 
-def _get_parameters(node, node_name):
-    name_to_type_map = {}
-    name_to_description_map = {}
-    parameter_names = call_list_parameters(node=node, node_name=node_name)
-    sorted_names = sorted(parameter_names)
-    resp = call_describe_parameters(
-        node=node, node_name=node_name, parameter_names=sorted_names
-    )
-    for descriptor in resp.descriptors:
-        name_to_type_map[descriptor.name] = get_parameter_type_string(descriptor.type)
-        name_to_description_map[descriptor.name] = descriptor.description
-    return sorted_names, name_to_type_map, name_to_description_map
+def update_documentation(node, node_name, file_path):
+    """Update the documentation for the given node."""
+    # Parse the document
+    parser = DocParser(file_path)
+    parser.parse()
+    doc_interface = parser.get_node_interface(node_name)
+    if not doc_interface:
+        print(f"Node '{node_name}' was not found in the documentation.")
+        return
+
+    # Get the current node interface
+    interface_collector = NodeInterfaceCollector(node, node_name)
+    node_interface = interface_collector.get_interfaces()
+
+    # Check if parameter names are the same
+    if sorted(doc_interface["parameters"].keys()) == sorted(
+        node_interface["parameters"].keys()
+    ):
+        for doc_param, node_param in zip(
+            sorted(doc_interface["parameters"].keys()),
+            sorted(node_interface["parameters"].keys()),
+        ):
+            # Check if the types are different
+            if (
+                doc_interface["parameters"][doc_param]["type"]
+                != node_interface["parameters"][node_param]["type"]
+            ):
+                node_interface["parameters"][node_param]["type"] = doc_interface[
+                    "parameters"
+                ][doc_param]["type"]
+            if (
+                doc_interface["parameters"][doc_param]["description"]
+                != node_interface["parameters"][node_param]["description"]
+                and doc_interface["parameters"][doc_param]["description"] != TODO
+            ):
+                node_interface["parameters"][node_param]["description"] = doc_interface[
+                    "parameters"
+                ][doc_param]["description"]
+    # If parameters are not the same
+    else:
+        pass

ros2autodoc/api/doc_parser.py

@@ -0,0 +1,204 @@
+import os
+import re
+
+
+class DocParser:
+    def __init__(self, path):
+        self.path = path
+        self.text_to_keep = []
+        self.nodes = {}
+
+    def parse(self):
+        """Parse the documentation."""
+        if not os.path.exists(self.path):
+            print("File not found.")
+            return
+
+        with open(self.path) as file:
+            start_parsing = False
+            parse_params = False
+            parse_subs = False
+            parse_pubs = False
+            parse_srvs = False
+            parse_actions = False
+
+            for line in file:
+                if line.strip().startswith("## Nodes"):
+                    self.text_to_keep.append(line)
+                    start_parsing = True
+                    continue
+
+                if not start_parsing:
+                    self.text_to_keep.append(line)
+                    continue
+
+                if line.strip().startswith("### Parameters"):
+                    parse_params = True
+                    parse_subs = False
+                    parse_pubs = False
+                    parse_srvs = False
+                    parse_actions = False
+                    continue
+                elif line.strip().startswith("### Subscribers"):
+                    parse_params = False
+                    parse_subs = True
+                    parse_pubs = False
+                    parse_srvs = False
+                    parse_actions = False
+                    continue
+                elif line.strip().startswith("### Publishers"):
+                    parse_params = False
+                    parse_subs = False
+                    parse_pubs = True
+                    parse_srvs = False
+                    parse_actions = False
+                    continue
+                elif line.strip().startswith("### Services"):
+                    parse_params = False
+                    parse_subs = False
+                    parse_pubs = False
+                    parse_srvs = True
+                    parse_actions = False
+                    continue
+                elif line.strip().startswith("### Actions"):
+                    parse_params = False
+                    parse_subs = False
+                    parse_pubs = False
+                    parse_srvs = False
+                    parse_actions = True
+                    continue
+                elif line.strip().startswith("### "):
+                    # Rest flags
+                    parse_params = False
+                    parse_subs = False
+                    parse_pubs = False
+                    parse_srvs = False
+                    parse_actions = False
+
+                    # Create new node
+                    curr_node_name = line.strip()[4:]
+                    self.nodes[curr_node_name] = {
+                        "parameters": {},
+                        "subscribers": {},
+                        "publishers": {},
+                        "services": {},
+                        "actions": {},
+                    }
+                    continue
+
+                if parse_params:
+                    if line.startswith("- **"):
+                        param_name = line.split("**`")[1].split("`**")[0]
+                        if param_name:
+                            self.nodes[curr_node_name]["parameters"][param_name] = {
+                                "type": "",
+                                "description": "",
+                            }
+                            match = re.search(r"\((.*?)\)", line)
+                            if match:
+                                data_type = match.group(1)
+                            else:
+                                data_type = ""
+                            self.nodes[curr_node_name]["parameters"][param_name][
+                                "type"
+                            ] = data_type
+                    elif line.startswith("    ") and line.strip():
+                        self.nodes[curr_node_name]["parameters"][param_name][
+                            "description"
+                        ] = line.strip()
+                    continue
+
+                elif parse_subs:
+                    if line.startswith("- **"):
+                        sub_name = line.split("**`")[1].split("`**")[0]
+                        if sub_name:
+                            self.nodes[curr_node_name]["subscribers"][sub_name] = {
+                                "type": "",
+                                "description": "",
+                            }
+                            match = re.search(r"\((.*?)\)", line)
+                            if match:
+                                data_type = match.group(1)
+                            else:
+                                data_type = ""
+                            self.nodes[curr_node_name]["subscribers"][sub_name][
+                                "type"
+                            ] = data_type
+                    elif line.startswith("    ") and sub_name:
+                        self.nodes[curr_node_name]["subscribers"][sub_name][
+                            "description"
+                        ] = line.strip()
+                    continue
+
+                elif parse_pubs:
+                    if line.startswith("- **"):
+                        pub_name = line.split("**`")[1].split("`**")[0]
+                        if pub_name:
+                            self.nodes[curr_node_name]["publishers"][pub_name] = {
+                                "type": "",
+                                "description": "",
+                            }
+                            match = re.search(r"\((.*?)\)", line)
+                            if match:
+                                data_type = match.group(1)
+                            else:
+                                data_type = ""
+                            self.nodes[curr_node_name]["publishers"][pub_name][
+                                "type"
+                            ] = data_type
+                    elif line.startswith("    ") and pub_name:
+                        self.nodes[curr_node_name]["publishers"][pub_name][
+                            "description"
+                        ] = line.strip()
+                    continue
+
+                elif parse_srvs:
+                    if line.startswith("- **"):
+                        srvs_name = line.split("**`")[1].split("`**")[0]
+                        if srvs_name:
+                            self.nodes[curr_node_name]["services"][srvs_name] = {
+                                "type": "",
+                                "description": "",
+                            }
+                            match = re.search(r"\((.*?)\)", line)
+                            if match:
+                                data_type = match.group(1)
+                            else:
+                                data_type = ""
+                            self.nodes[curr_node_name]["services"][srvs_name][
+                                "type"
+                            ] = data_type
+                    elif line.startswith("    ") and srvs_name:
+                        self.nodes[curr_node_name]["services"][srvs_name][
+                            "description"
+                        ] = line.strip()
+                    continue
+
+                elif parse_actions:
+                    if line.startswith("- **"):
+                        action_name = line.split("**`")[1].split("`**")[0]
+                        if action_name:
+                            self.nodes[curr_node_name]["actions"][action_name] = {
+                                "type": "",
+                                "description": "",
+                            }
+                            match = re.search(r"\((.*?)\)", line)
+                            if match:
+                                data_type = match.group(1)
+                            else:
+                                data_type = ""
+                            self.nodes[curr_node_name]["actions"][action_name][
+                                "type"
+                            ] = data_type
+                    elif line.startswith("    ") and action_name:
+                        self.nodes[curr_node_name]["actions"][action_name][
+                            "description"
+                        ] = line.strip()
+
+    def get_nodes(self):
+        return self.nodes
+
+    def get_node_interface(self, node_name):
+        if node_name in self.nodes:
+            return self.nodes[node_name]
+        return None