graph_database: Add has_link variant to check for specific link

The former GraphDatabase.has_link method checked if a node had any link.
Rename it to has_any_link and add a new method to check if there's one
specific link between two nodes. The new method is symmetrical to
create_link.

Author: haxtibal

strictdoc/core/graph/abstract_bucket.py

@@ -8,7 +8,13 @@
 
 class AbstractBucket(ABC):
     @abstractmethod
-    def has_link(self, *, lhs_node: Any) -> bool:
+    def has_any_link(self, *, lhs_node: Any) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    def has_link(
+        self, *, lhs_node: Any, rhs_node: Any, edge: Optional[str] = None
+    ) -> bool:
         raise NotImplementedError
 
     @abstractmethod

strictdoc/core/graph/many_to_many_set.py

@@ -14,10 +14,16 @@ def __init__(self, lhs_type: Type[Any], rhs_type: Type[Any]) -> None:
         self._lhs_type: type = lhs_type
         self._rhs_type: type = rhs_type
 
-    def has_link(self, *, lhs_node: Any) -> bool:
+    def has_any_link(self, *, lhs_node: Any) -> bool:
         assert isinstance(lhs_node, self._lhs_type), lhs_node
         return lhs_node in self._links and len(self._links[lhs_node]) > 0
 
+    def has_link(
+        self, *, lhs_node: Any, rhs_node: Any, edge: Optional[str] = None
+    ) -> bool:
+        assert isinstance(rhs_node, self._rhs_type), rhs_node
+        return rhs_node in self.get_link_values(lhs_node=lhs_node, edge=edge)
+
     def get_count(self, edge: Optional[str] = None) -> int:
         total_count = 0
         for _, lhs_node_links in self._links.items():

strictdoc/core/graph/one_to_one_dictionary.py

@@ -13,10 +13,18 @@ def __init__(
         self._lhs_type: Type[Any] = lhs_type
         self._rhs_type: Union[Type[Any], Tuple[Type[Any], ...]] = rhs_type
 
-    def has_link(self, *, lhs_node: Any) -> bool:
+    def has_any_link(self, *, lhs_node: Any) -> bool:
         assert isinstance(lhs_node, self._lhs_type), (lhs_node, self._lhs_type)
         return lhs_node in self._dict
 
+    def has_link(
+        self, *, lhs_node: Any, rhs_node: Any, edge: Optional[str] = None
+    ) -> bool:
+        assert edge is None
+        assert isinstance(lhs_node, self._lhs_type), (lhs_node, self._lhs_type)
+        assert isinstance(rhs_node, self._rhs_type), (rhs_node, self._rhs_type)
+        return lhs_node in self._dict and rhs_node is self._dict[lhs_node]
+
     def get_count(self) -> int:
         return len(self._dict)
 

strictdoc/core/graph_database.py

@@ -21,8 +21,20 @@ def __init__(self, buckets: List[Tuple[Any, AbstractBucket]]):
             assert bucket_[0] not in self._id_to_bucket
             self._id_to_bucket[bucket_[0]] = bucket_[1]
 
-    def has_link(self, *, link_type: Hashable, lhs_node: Any) -> bool:
-        return self._id_to_bucket[link_type].has_link(lhs_node=lhs_node)
+    def has_any_link(self, *, link_type: Hashable, lhs_node: Any) -> bool:
+        return self._id_to_bucket[link_type].has_any_link(lhs_node=lhs_node)
+
+    def has_link(
+        self,
+        *,
+        link_type: Hashable,
+        lhs_node: Any,
+        rhs_node: Any,
+        edge: Optional[str] = None,
+    ) -> bool:
+        return self._id_to_bucket[link_type].has_link(
+            lhs_node=lhs_node, rhs_node=rhs_node, edge=edge
+        )
 
     def get_count(self, *, link_type: Hashable) -> int:
         return self._id_to_bucket[link_type].get_count()

strictdoc/core/traceability_index.py

@@ -134,7 +134,7 @@ def has_source_file_reqs(self, source_file_rel_path: str) -> bool:
 
     def has_node_connections(self, node_uid: str) -> bool:
         assert isinstance(node_uid, str), node_uid
-        return self.graph_database.has_link(
+        return self.graph_database.has_any_link(
             link_type=GraphLinkType.UID_TO_NODE,
             lhs_node=node_uid,
         )
@@ -244,7 +244,7 @@ def get_children_requirements(
         )
 
     def has_tags(self, document: SDocDocument) -> bool:
-        return self.graph_database.has_link(
+        return self.graph_database.has_any_link(
             link_type=GraphLinkType.DOCUMENT_TO_TAGS,
             lhs_node=document.reserved_mid,
         )
@@ -379,7 +379,7 @@ def create_inline_link(self, new_link: InlineLink) -> None:
         assert isinstance(new_link, InlineLink)
 
         # InlineLink points to a section, node or to anchor.
-        assert self.graph_database.has_link(
+        assert self.graph_database.has_any_link(
             link_type=GraphLinkType.UID_TO_NODE, lhs_node=new_link.link
         )
 
@@ -872,7 +872,7 @@ def validate_node_against_anchors(
         # by the new anchors.
         if node is None:
             for anchor_uid in new_anchor_uids:
-                if self.graph_database.has_link(
+                if self.graph_database.has_any_link(
                     link_type=GraphLinkType.UID_TO_NODE, lhs_node=anchor_uid
                 ):
                     raise SingleValidationError(
@@ -904,7 +904,7 @@ def validate_node_against_anchors(
         #
         for anchor_uid in new_anchor_uids:
             if (
-                self.graph_database.has_link(
+                self.graph_database.has_any_link(
                     link_type=GraphLinkType.UID_TO_NODE, lhs_node=anchor_uid
                 )
                 and anchor_uid not in existing_node_anchor_uids

strictdoc/core/traceability_index_builder.py

@@ -395,7 +395,7 @@ def create_from_document_tree(
                 print(exc.to_print_message())  # noqa: T201
                 sys.exit(1)
 
-            if graph_database.has_link(
+            if graph_database.has_any_link(
                 link_type=GraphLinkType.MID_TO_NODE,
                 lhs_node=document.reserved_mid,
             ):
@@ -452,7 +452,7 @@ def create_from_document_tree(
                         print(exc.to_print_message())  # noqa: T201
                         sys.exit(1)
 
-                if graph_database.has_link(
+                if graph_database.has_any_link(
                     link_type=GraphLinkType.MID_TO_NODE,
                     lhs_node=node.reserved_mid,
                 ):
@@ -478,7 +478,7 @@ def create_from_document_tree(
 
                 if node.reserved_uid is not None:
                     # @relation(SDOC-SRS-29, scope=range_start)
-                    if traceability_index.graph_database.has_link(
+                    if traceability_index.graph_database.has_any_link(
                         link_type=GraphLinkType.UID_TO_NODE,
                         lhs_node=node.reserved_uid,
                     ):
@@ -565,7 +565,7 @@ def create_from_document_tree(
                 for node_field_ in requirement.enumerate_fields():
                     for part in node_field_.parts:
                         if isinstance(part, InlineLink):
-                            if not graph_database.has_link(
+                            if not graph_database.has_any_link(
                                 link_type=GraphLinkType.UID_TO_NODE,
                                 lhs_node=part.link,
                             ):

tests/unit/strictdoc/core/test_graph_database.py

@@ -26,18 +26,36 @@ def __init__(self, title):
         ]
     )
 
+    assert (
+        graph_database.has_link(
+            link_type=Relation.INLINE_LINK_TO_ANCHOR,
+            lhs_node=inline_link,
+            rhs_node=anchor,
+        )
+        is False
+    )
+
     graph_database.create_link(
         link_type=Relation.INLINE_LINK_TO_ANCHOR,
         lhs_node=inline_link,
         rhs_node=anchor,
     )
+
     assert (
         graph_database.get_link_value(
             link_type=Relation.INLINE_LINK_TO_ANCHOR,
             lhs_node=inline_link,
         )
         == anchor
     )
+    assert (
+        graph_database.has_link(
+            link_type=Relation.INLINE_LINK_TO_ANCHOR,
+            lhs_node=inline_link,
+            rhs_node=anchor,
+        )
+        is True
+    )
 
     graph_database.delete_link(
         link_type=Relation.INLINE_LINK_TO_ANCHOR,
@@ -52,6 +70,14 @@ def __init__(self, title):
         )
         is None
     )
+    assert (
+        graph_database.has_link(
+            link_type=Relation.INLINE_LINK_TO_ANCHOR,
+            lhs_node=inline_link,
+            rhs_node=anchor,
+        )
+        is False
+    )
 
 
 def test_02_basic():
@@ -69,11 +95,28 @@ def __init__(self, title):
         buckets=[(Relation.INLINE_LINK_TO_ANCHOR, ManyToManySet(Node, Node))]
     )
 
+    assert (
+        graph_database.has_link(
+            link_type=Relation.INLINE_LINK_TO_ANCHOR,
+            lhs_node=anchor,
+            rhs_node=inline_link,
+        )
+        is False
+    )
+
     graph_database.create_link(
         link_type=Relation.INLINE_LINK_TO_ANCHOR,
         lhs_node=anchor,
         rhs_node=inline_link,
     )
+    assert (
+        graph_database.has_link(
+            link_type=Relation.INLINE_LINK_TO_ANCHOR,
+            lhs_node=anchor,
+            rhs_node=inline_link,
+        )
+        is True
+    )
     assert graph_database.get_link_values_reverse(
         link_type=Relation.INLINE_LINK_TO_ANCHOR, rhs_node=inline_link
     ) == {anchor}

tests/unit/strictdoc/core/test_many2many_set.py

@@ -14,7 +14,7 @@ def test_01_basic():
     many2many_set.create_link(lhs_node=1, rhs_node=3)
     many2many_set.create_link(lhs_node=1, rhs_node=4)
 
-    assert many2many_set.has_link(lhs_node=1)
+    assert many2many_set.has_any_link(lhs_node=1)
 
     assert many2many_set.get_link_values(lhs_node=1) == {2, 3, 4}
     assert many2many_set.get_link_values_reverse(rhs_node=2) == {1}
@@ -31,7 +31,7 @@ def test_01_basic():
     assert many2many_set.get_link_values_reverse(rhs_node=3) == OrderedSet()
     assert many2many_set.get_link_values_reverse(rhs_node=4) == OrderedSet()
 
-    assert not many2many_set.has_link(lhs_node=1)
+    assert not many2many_set.has_any_link(lhs_node=1)
 
 
 def test_02_basic():