Dev

.gitignore

@@ -16,6 +16,5 @@ delete.py
 *.json
 static/
 
-
 !blarify/vendor/**/*.json
 

blarify/code_hierarchy/languages/__init__.py

@@ -6,3 +6,4 @@
 from .fallback_definitions import FallbackDefinitions
 from .csharp_definitions import CsharpDefinitions
 from .go_definitions import GoDefinitions
+from .dart_definitions import DartDefinitions

blarify/code_hierarchy/languages/dart_definitions.py

@@ -0,0 +1,117 @@
+from blarify.code_hierarchy.languages.FoundRelationshipScope import FoundRelationshipScope
+from .language_definitions import LanguageDefinitions
+from blarify.graph.relationship import RelationshipType
+
+from tree_sitter_language_pack import get_parser
+from tree_sitter import Parser
+
+from typing import Optional, Set, Dict
+
+from blarify.graph.node import NodeLabels
+from tree_sitter import Node
+from blarify.graph.node import Node as GraphNode
+
+
+class DartDefinitions(LanguageDefinitions):
+    def get_language_name() -> str:
+        return "dart"
+
+    def get_parsers_for_extensions() -> Dict[str, Parser]:
+        return {
+            ".dart": get_parser("dart"),
+        }
+
+    def should_create_node(node: Node) -> bool:
+        if node.type == "method_signature":
+            return DartDefinitions.is_method_signature_a_definition(node)
+
+        return LanguageDefinitions._should_create_node_base_implementation(
+            node,
+            [
+                "class_definition",
+            ],
+        )
+
+    def is_method_signature_a_definition(node: Node) -> bool:
+        is_method_signature = node.type == "method_signature"
+        next_named_sibling = DartDefinitions._get_next_named_sibling(node, skip_comments=True)
+        contains_declaration = len(DartDefinitions._get_children_by_type(node, "function_signature")) > 0
+
+        return (
+            is_method_signature
+            and next_named_sibling
+            and next_named_sibling.type == "function_body"
+            and contains_declaration
+        )
+
+    def _get_next_named_sibling(node: Node, skip_comments: bool) -> Optional[Node]:
+        sibling = node.next_named_sibling
+        if skip_comments:
+            while sibling and sibling.type == "comment":
+                sibling = sibling.next_named_sibling
+
+        return sibling
+
+    def get_identifier_node(node: Node) -> Node:
+        if node.type == "method_signature":
+            function_signature_node = DartDefinitions._get_children_by_type(node, "function_signature")
+            print(function_signature_node)
+            node = function_signature_node[0]
+
+        return LanguageDefinitions._get_identifier_node_base_implementation(node)
+
+    def _get_children_by_type(node: Node, type: str) -> list[Node]:
+        return [child for child in node.children if child.type == type]
+
+    def _get_method_signature_identifier_node(node: Node) -> Node:
+        return DartDefinitions._get_next_named_sibling(node, skip_comments=True) or node
+
+    def _get_first_child(node: Node, skip_comments: bool) -> Optional[Node]:
+        child = node.named_child(0)
+        if skip_comments:
+            while child and child.type == "comment":
+                child = child.next_named_sibling
+
+    def get_body_node(node: Node) -> Node:
+        if node.type == "method_signature":
+            node = node.next_named_sibling
+
+        return LanguageDefinitions._get_body_node_base_implementation(node)
+
+    def get_relationship_type(node: GraphNode, node_in_point_reference: Node) -> Optional[FoundRelationshipScope]:
+        return DartDefinitions._find_relationship_type(
+            node_label=node.label,
+            node_in_point_reference=node_in_point_reference,
+        )
+
+    def get_node_label_from_type(type: str) -> NodeLabels:
+        print(type)
+        return {
+            "class_definition": NodeLabels.CLASS,
+            "method_signature": NodeLabels.FUNCTION,
+        }[type]
+
+    def get_language_file_extensions() -> Set[str]:
+        return {".dart"}
+
+    def _find_relationship_type(node_label: str, node_in_point_reference: Node) -> Optional[FoundRelationshipScope]:
+        relationship_types = DartDefinitions._get_relationship_types_by_label()
+        relevant_relationship_types = relationship_types.get(node_label, {})
+
+        return LanguageDefinitions._traverse_and_find_relationships(
+            node_in_point_reference, relevant_relationship_types
+        )
+
+    def _get_relationship_types_by_label() -> dict[str, RelationshipType]:
+        return {
+            NodeLabels.CLASS: {
+                "object_creation_expression": RelationshipType.INSTANTIATES,
+                "using_directive": RelationshipType.IMPORTS,
+                "variable_declaration": RelationshipType.TYPES,
+                "parameter": RelationshipType.TYPES,
+                "base_list": RelationshipType.INHERITS,
+            },
+            NodeLabels.FUNCTION: {
+                "invocation_expression": RelationshipType.CALLS,
+            },
+        }

blarify/code_hierarchy/tree_sitter_helper.py

@@ -241,3 +241,8 @@ def _empty_reference(self) -> "Reference":
             ),
             uri=self.current_path,
         )
+
+    def pretty_print(self, tree_sitter_node: "TreeSitterNode", indent: int = 0) -> None:
+        print(" " * indent + f"{{{tree_sitter_node.type}}} {tree_sitter_node.text.decode('utf-8')}")
+        for child in tree_sitter_node.children:
+            self.pretty_print(child, indent + 1)

blarify/code_references/lsp_helper.py

@@ -3,7 +3,7 @@
 import psutil
 
 from blarify.vendor.multilspy import SyncLanguageServer
-
+from blarify.vendor.multilspy.lsp_protocol_handler.server import Error
 from blarify.utils.path_calculator import PathCalculator
 
 from .types.Reference import Reference
@@ -15,6 +15,7 @@
     TypescriptDefinitions,
     LanguageDefinitions,
     CsharpDefinitions,
+    DartDefinitions,
     GoDefinitions,
 )
 
@@ -58,6 +59,8 @@ def _get_language_definition_for_extension(self, extension: str) -> LanguageDefi
             return CsharpDefinitions
         elif extension in GoDefinitions.get_language_file_extensions():
             return GoDefinitions
+        elif extension in DartDefinitions.get_language_file_extensions():
+            return DartDefinitions
         else:
             raise FileExtensionNotSupported(f'File extension "{extension}" is not supported)')
 

blarify/examples/graph_builder.py

@@ -15,7 +15,8 @@ def build(root_path: str = None):
     relationships = graph.get_relationships_as_objects()
     nodes = graph.get_nodes_as_objects()
 
-    save_to_falkordb(relationships, nodes)
+    # save_to_falkordb(relationships, nodes)
+    save_to_neo4j(relationships, nodes)
 
 
 def save_to_neo4j(relationships, nodes):

blarify/project_graph_creator.py

@@ -12,6 +12,7 @@
     TypescriptDefinitions,
     FallbackDefinitions,
     RubyDefinitions,
+    DartDefinitions,
     CsharpDefinitions,
 )
 from typing import List, TYPE_CHECKING
@@ -43,6 +44,7 @@ class ProjectGraphCreator:
         ".rb": RubyDefinitions,
         ".cs": CsharpDefinitions,
         ".go": GoDefinitions,
+        ".dart": DartDefinitions,
     }
 
     def __init__(

blarify/utils/initialize_all_language_servers.py

@@ -39,11 +39,10 @@ def initialize_all_language_servers():
         print(f"Starting language server for {language}, current_dir_path: {current_dir_path}")
 
         try:
-            lsp: SyncLanguageServer = SyncLanguageServer.create(
+            SyncLanguageServer.create(
                 config=config, logger=logger, repository_root_path=current_dir_path, timeout=15
             )
-            with lsp.start_server():
-                my_logger.info(f"Started language server for {language}")
+            my_logger.info(f"Started language server for {language}")
         except Exception as e:
             my_logger.warning(f"Failed to start language server for {language}: {e}")