osscodeiq 0.0.0__py3-none-any.whl

osscodeiq/detectors/rust/actix_web.py

@@ -0,0 +1,234 @@
+"""Actix-web and Axum web framework detector for Rust source files."""
+
+from __future__ import annotations
+
+import re
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+# Actix attribute macros: #[get("/path")], #[post("/path")], etc.
+_ACTIX_ATTR_RE = re.compile(r'#\[(get|post|put|delete)\s*\(\s*"([^"]*)"\s*\)\s*\]')
+
+# HttpServer::new(
+_HTTP_SERVER_RE = re.compile(r"HttpServer::new\s*\(")
+
+# .route("/path", web::get().to(handler))
+_ROUTE_RE = re.compile(r'\.route\s*\(\s*"([^"]*)"\s*,\s*web::(get|post|put|delete)\s*\(\s*\)\s*\.to\s*\(\s*(\w+)')
+
+# .service(web::resource("/path"))
+_SERVICE_RESOURCE_RE = re.compile(r'\.service\s*\(\s*web::resource\s*\(\s*"([^"]*)"')
+
+# Axum: Router::new().route("/path", get(handler))
+_AXUM_ROUTE_RE = re.compile(r'\.route\s*\(\s*"([^"]*)"\s*,\s*(get|post|put|delete)\s*\(\s*(\w+)\s*\)')
+
+# Axum: .layer(middleware)
+_AXUM_LAYER_RE = re.compile(r"\.layer\s*\(\s*(\w+)")
+
+# #[actix_web::main] or #[tokio::main]
+_MAIN_ATTR_RE = re.compile(r"#\[(actix_web::main|tokio::main)\]")
+
+# fn function_name
+_FN_RE = re.compile(r"(?:pub\s+)?(?:async\s+)?fn\s+(\w+)")
+
+
+class ActixWebDetector:
+    """Detects Actix-web and Axum web framework patterns in Rust source files."""
+
+    name: str = "actix_web"
+    supported_languages: tuple[str, ...] = ("rust",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        # Fast bail
+        if not any(
+            marker in text
+            for marker in (
+                "#[get",
+                "#[post",
+                "#[put",
+                "#[delete",
+                "HttpServer::new",
+                "web::get",
+                "web::post",
+                "web::resource",
+                "Router::new",
+                ".layer(",
+                "actix_web::main",
+                "tokio::main",
+                "actix_web",
+                "axum",
+            )
+        ):
+            return result
+
+        lines = text.split("\n")
+
+        for i, line in enumerate(lines):
+            lineno = i + 1
+
+            # Actix attribute macros
+            m = _ACTIX_ATTR_RE.search(line)
+            if m:
+                method = m.group(1).upper()
+                path = m.group(2)
+
+                # Find the function name on subsequent lines
+                fn_name: str | None = None
+                for k in range(i + 1, min(i + 5, len(lines))):
+                    fm = _FN_RE.search(lines[k])
+                    if fm:
+                        fn_name = fm.group(1)
+                        break
+
+                node_id = f"rust_web:{ctx.file_path}:{method}:{path}:{lineno}"
+                result.nodes.append(
+                    GraphNode(
+                        id=node_id,
+                        kind=NodeKind.ENDPOINT,
+                        label=f"{method} {path}",
+                        fqn=fn_name,
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=lineno),
+                        annotations=[f"#[{m.group(1)}]"],
+                        properties={
+                            "framework": "actix_web",
+                            "http_method": method,
+                            "path": path,
+                        },
+                    )
+                )
+
+            # HttpServer::new
+            m = _HTTP_SERVER_RE.search(line)
+            if m:
+                node_id = f"rust_web:{ctx.file_path}:http_server:{lineno}"
+                result.nodes.append(
+                    GraphNode(
+                        id=node_id,
+                        kind=NodeKind.MODULE,
+                        label="HttpServer",
+                        fqn="HttpServer",
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=lineno),
+                        annotations=[],
+                        properties={"framework": "actix_web"},
+                    )
+                )
+
+            # .route("/path", web::get().to(handler))
+            m = _ROUTE_RE.search(line)
+            if m:
+                path = m.group(1)
+                method = m.group(2).upper()
+                handler = m.group(3)
+                node_id = f"rust_web:{ctx.file_path}:{method}:{path}:{lineno}"
+                result.nodes.append(
+                    GraphNode(
+                        id=node_id,
+                        kind=NodeKind.ENDPOINT,
+                        label=f"{method} {path}",
+                        fqn=handler,
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=lineno),
+                        annotations=[],
+                        properties={
+                            "framework": "actix_web",
+                            "http_method": method,
+                            "path": path,
+                            "handler": handler,
+                        },
+                    )
+                )
+
+            # .service(web::resource("/path"))
+            m = _SERVICE_RESOURCE_RE.search(line)
+            if m:
+                path = m.group(1)
+                node_id = f"rust_web:{ctx.file_path}:resource:{path}:{lineno}"
+                result.nodes.append(
+                    GraphNode(
+                        id=node_id,
+                        kind=NodeKind.ENDPOINT,
+                        label=f"resource {path}",
+                        fqn=path,
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=lineno),
+                        annotations=[],
+                        properties={"framework": "actix_web", "path": path},
+                    )
+                )
+
+            # Axum Router::new().route("/path", get(handler))
+            m = _AXUM_ROUTE_RE.search(line)
+            if m:
+                path = m.group(1)
+                method = m.group(2).upper()
+                handler = m.group(3)
+                node_id = f"rust_web:{ctx.file_path}:{method}:{path}:{lineno}"
+                result.nodes.append(
+                    GraphNode(
+                        id=node_id,
+                        kind=NodeKind.ENDPOINT,
+                        label=f"{method} {path}",
+                        fqn=handler,
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=lineno),
+                        annotations=[],
+                        properties={
+                            "framework": "axum",
+                            "http_method": method,
+                            "path": path,
+                            "handler": handler,
+                        },
+                    )
+                )
+
+            # Axum .layer(middleware)
+            m = _AXUM_LAYER_RE.search(line)
+            if m:
+                middleware_name = m.group(1)
+                node_id = f"rust_web:{ctx.file_path}:layer:{middleware_name}:{lineno}"
+                result.nodes.append(
+                    GraphNode(
+                        id=node_id,
+                        kind=NodeKind.MIDDLEWARE,
+                        label=f"layer({middleware_name})",
+                        fqn=middleware_name,
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=lineno),
+                        annotations=[],
+                        properties={"framework": "axum", "middleware": middleware_name},
+                    )
+                )
+
+            # #[actix_web::main] / #[tokio::main]
+            m = _MAIN_ATTR_RE.search(line)
+            if m:
+                attr = m.group(1)
+                node_id = f"rust_web:{ctx.file_path}:main:{lineno}"
+                result.nodes.append(
+                    GraphNode(
+                        id=node_id,
+                        kind=NodeKind.MODULE,
+                        label=f"#[{attr}]",
+                        fqn="main",
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=lineno),
+                        annotations=[f"#[{attr}]"],
+                        properties={
+                            "framework": "actix_web" if "actix" in attr else "tokio",
+                        },
+                    )
+                )
+
+        return result

osscodeiq/detectors/rust/rust_structures.py

@@ -0,0 +1,174 @@
+"""Regex-based Rust structures detector for Rust source files."""
+
+from __future__ import annotations
+
+import re
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text, find_line_number
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+_RUST_USE_RE = re.compile(r'^\s*use\s+([\w:]+)', re.MULTILINE)
+_RUST_STRUCT_RE = re.compile(r'^\s*(?:pub\s+)?struct\s+(\w+)', re.MULTILINE)
+_RUST_TRAIT_RE = re.compile(r'^\s*(?:pub\s+)?trait\s+(\w+)', re.MULTILINE)
+# FIX: Match both trait impls (`impl X for Y`) and inherent impls (`impl Foo`).
+# Group 1 = first type, Group 2 = second type (None for inherent impls).
+_RUST_IMPL_RE = re.compile(
+    r'^\s*impl(?:<[^>]*>)?\s+(\w+)(?:\s+for\s+(\w+))?\s*\{',
+    re.MULTILINE,
+)
+# FIX: Match async fn, pub async fn, pub(crate) fn, etc.
+_RUST_FN_RE = re.compile(
+    r'^\s*(?:pub(?:\([^)]*\))?\s+)?(?:async\s+)?(?:unsafe\s+)?fn\s+(\w+)\s*\(',
+    re.MULTILINE,
+)
+_RUST_MOD_RE = re.compile(r'^\s*(?:pub\s+)?mod\s+(\w+)', re.MULTILINE)
+_RUST_ENUM_RE = re.compile(r'^\s*(?:pub\s+)?enum\s+(\w+)', re.MULTILINE)
+# FIX: Add macro_rules! detection.
+_RUST_MACRO_RE = re.compile(r'^\s*macro_rules!\s+(\w+)', re.MULTILINE)
+
+
+
+class RustStructuresDetector:
+    """Detects Rust imports, structs, traits, impls, functions, enums, modules, and macros."""
+
+    name: str = "rust_structures"
+    supported_languages: tuple[str, ...] = ("rust",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+        file_node_id = ctx.file_path
+
+        for m in _RUST_USE_RE.finditer(text):
+            target = m.group(1)
+            result.edges.append(GraphEdge(
+                source=file_node_id,
+                target=target,
+                kind=EdgeKind.IMPORTS,
+                label=f"{ctx.file_path} imports {target}",
+            ))
+
+        for m in _RUST_MOD_RE.finditer(text):
+            mod_name = m.group(1)
+            result.nodes.append(GraphNode(
+                id=f"{ctx.file_path}:mod:{mod_name}",
+                kind=NodeKind.MODULE,
+                label=mod_name,
+                fqn=mod_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=find_line_number(text, m.start()),
+                ),
+            ))
+
+        for m in _RUST_STRUCT_RE.finditer(text):
+            struct_name = m.group(1)
+            result.nodes.append(GraphNode(
+                id=f"{ctx.file_path}:{struct_name}",
+                kind=NodeKind.CLASS,
+                label=struct_name,
+                fqn=struct_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=find_line_number(text, m.start()),
+                ),
+                properties={"type": "struct"},
+            ))
+
+        for m in _RUST_TRAIT_RE.finditer(text):
+            trait_name = m.group(1)
+            result.nodes.append(GraphNode(
+                id=f"{ctx.file_path}:{trait_name}",
+                kind=NodeKind.INTERFACE,
+                label=trait_name,
+                fqn=trait_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=find_line_number(text, m.start()),
+                ),
+                properties={"type": "trait"},
+            ))
+
+        for m in _RUST_ENUM_RE.finditer(text):
+            enum_name = m.group(1)
+            result.nodes.append(GraphNode(
+                id=f"{ctx.file_path}:{enum_name}",
+                kind=NodeKind.ENUM,
+                label=enum_name,
+                fqn=enum_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=find_line_number(text, m.start()),
+                ),
+            ))
+
+        # FIX: Handle both trait impls and inherent impls.
+        for m in _RUST_IMPL_RE.finditer(text):
+            first = m.group(1)
+            second = m.group(2)
+            if second:
+                # Trait impl: `impl Trait for Struct`
+                trait_name = first
+                struct_name = second
+                struct_node_id = f"{ctx.file_path}:{struct_name}"
+                trait_node_id = f"{ctx.file_path}:{trait_name}"
+                result.edges.append(GraphEdge(
+                    source=struct_node_id,
+                    target=trait_node_id,
+                    kind=EdgeKind.IMPLEMENTS,
+                    label=f"{struct_name} implements {trait_name}",
+                ))
+            else:
+                # Inherent impl: `impl Foo {`
+                struct_name = first
+                struct_node_id = f"{ctx.file_path}:{struct_name}"
+                result.edges.append(GraphEdge(
+                    source=struct_node_id,
+                    target=struct_node_id,
+                    kind=EdgeKind.DEFINES,
+                    label=f"{struct_name} inherent impl",
+                ))
+
+        for m in _RUST_FN_RE.finditer(text):
+            fn_name = m.group(1)
+            result.nodes.append(GraphNode(
+                id=f"{ctx.file_path}:{fn_name}",
+                kind=NodeKind.METHOD,
+                label=fn_name,
+                fqn=fn_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=find_line_number(text, m.start()),
+                ),
+                properties={"type": "function"},
+            ))
+
+        # FIX: Detect macro_rules! definitions.
+        for m in _RUST_MACRO_RE.finditer(text):
+            macro_name = m.group(1)
+            result.nodes.append(GraphNode(
+                id=f"{ctx.file_path}:macro:{macro_name}",
+                kind=NodeKind.METHOD,
+                label=f"{macro_name}!",
+                fqn=f"{macro_name}!",
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=find_line_number(text, m.start()),
+                ),
+                properties={"type": "macro"},
+            ))
+
+        return result

osscodeiq/detectors/scala/scala_structures.py

@@ -0,0 +1,128 @@
+"""Regex-based Scala structures detector for Scala source files."""
+
+from __future__ import annotations
+
+import re
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text, find_line_number
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+_SCALA_IMPORT_RE = re.compile(r'^\s*import\s+([\w.]+)', re.MULTILINE)
+_SCALA_CLASS_RE = re.compile(
+    r'^\s*(?:case\s+)?class\s+(\w+)'
+    r'(?:\s+extends\s+(\w+))?'
+    r'(?:\s+with\s+([\w\s,]+))?',
+    re.MULTILINE,
+)
+_SCALA_TRAIT_RE = re.compile(r'^\s*trait\s+(\w+)', re.MULTILINE)
+_SCALA_OBJECT_RE = re.compile(r'^\s*object\s+(\w+)', re.MULTILINE)
+_SCALA_DEF_RE = re.compile(r'^\s*def\s+(\w+)\s*[\[(]', re.MULTILINE)
+
+
+
+class ScalaStructuresDetector:
+    """Detects Scala imports, classes, traits, objects, and methods."""
+
+    name: str = "scala_structures"
+    supported_languages: tuple[str, ...] = ("scala",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+        file_node_id = ctx.file_path
+
+        for m in _SCALA_IMPORT_RE.finditer(text):
+            target = m.group(1)
+            result.edges.append(GraphEdge(
+                source=file_node_id,
+                target=target,
+                kind=EdgeKind.IMPORTS,
+                label=f"{ctx.file_path} imports {target}",
+            ))
+
+        for m in _SCALA_CLASS_RE.finditer(text):
+            class_name = m.group(1)
+            base_class = m.group(2)
+            traits_str = m.group(3)
+            node_id = f"{ctx.file_path}:{class_name}"
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.CLASS,
+                label=class_name,
+                fqn=class_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=find_line_number(text, m.start()),
+                ),
+            ))
+            if base_class:
+                result.edges.append(GraphEdge(
+                    source=node_id,
+                    target=base_class,
+                    kind=EdgeKind.EXTENDS,
+                    label=f"{class_name} extends {base_class}",
+                ))
+            if traits_str:
+                for trait in traits_str.split(","):
+                    trait = trait.strip()
+                    if trait:
+                        result.edges.append(GraphEdge(
+                            source=node_id,
+                            target=trait,
+                            kind=EdgeKind.IMPLEMENTS,
+                            label=f"{class_name} implements {trait}",
+                        ))
+
+        for m in _SCALA_TRAIT_RE.finditer(text):
+            trait_name = m.group(1)
+            result.nodes.append(GraphNode(
+                id=f"{ctx.file_path}:{trait_name}",
+                kind=NodeKind.INTERFACE,
+                label=trait_name,
+                fqn=trait_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=find_line_number(text, m.start()),
+                ),
+                properties={"type": "trait"},
+            ))
+
+        for m in _SCALA_OBJECT_RE.finditer(text):
+            obj_name = m.group(1)
+            result.nodes.append(GraphNode(
+                id=f"{ctx.file_path}:{obj_name}",
+                kind=NodeKind.CLASS,
+                label=obj_name,
+                fqn=obj_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=find_line_number(text, m.start()),
+                ),
+                properties={"type": "object"},
+            ))
+
+        for m in _SCALA_DEF_RE.finditer(text):
+            method_name = m.group(1)
+            result.nodes.append(GraphNode(
+                id=f"{ctx.file_path}:{method_name}",
+                kind=NodeKind.METHOD,
+                label=method_name,
+                fqn=method_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=find_line_number(text, m.start()),
+                ),
+            ))
+
+        return result

osscodeiq/detectors/shell/bash_detector.py

@@ -0,0 +1,127 @@
+"""Bash/Shell script detector for functions, sourced files, exports, and tool usage."""
+
+from __future__ import annotations
+
+import re
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+_FUNC_RE = re.compile(r'(?:function\s+(\w+)|(\w+)\s*\(\s*\))\s*\{')
+_SOURCE_RE = re.compile(r'(?:source|\.) (?:")?([^\s"]+)')
+_SHEBANG_RE = re.compile(r'^#!\s*/(?:usr/)?(?:bin/)?(?:env\s+)?(\w+)')
+_EXPORT_RE = re.compile(r'export\s+(\w+)=')
+
+_INFRA_TOOLS = {"docker", "kubectl", "terraform", "aws", "az", "gcloud"}
+_TOOL_RE = re.compile(
+    r'\b(' + '|'.join(re.escape(t) for t in sorted(_INFRA_TOOLS)) + r')\b'
+)
+
+
+class BashDetector:
+    """Detects Bash/Shell script structures: functions, sourced files, exports, and tool usage."""
+
+    name: str = "bash"
+    supported_languages: tuple[str, ...] = ("bash",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+        lines = text.split("\n")
+
+        # Detect shebang
+        if lines:
+            m = _SHEBANG_RE.match(lines[0])
+            if m:
+                shell = m.group(1)
+                result.nodes.append(GraphNode(
+                    id=ctx.file_path,
+                    kind=NodeKind.MODULE,
+                    label=ctx.file_path,
+                    fqn=ctx.file_path,
+                    module=ctx.module_name,
+                    location=SourceLocation(
+                        file_path=ctx.file_path,
+                        line_start=1,
+                    ),
+                    properties={"shell": shell},
+                ))
+
+        # Detect function definitions
+        for i, line in enumerate(lines):
+            m = _FUNC_RE.search(line)
+            if not m:
+                continue
+            func_name = m.group(1) or m.group(2)
+
+            result.nodes.append(GraphNode(
+                id=f"{ctx.file_path}:{func_name}",
+                kind=NodeKind.METHOD,
+                label=func_name,
+                fqn=func_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=i + 1,
+                ),
+            ))
+
+        # Detect source/dot-source imports
+        for i, line in enumerate(lines):
+            m = _SOURCE_RE.search(line)
+            if not m:
+                continue
+            sourced_file = m.group(1)
+            result.edges.append(GraphEdge(
+                source=ctx.file_path,
+                target=sourced_file,
+                kind=EdgeKind.IMPORTS,
+                label=f"{ctx.file_path} sources {sourced_file}",
+            ))
+
+        # Detect exports
+        for i, line in enumerate(lines):
+            m = _EXPORT_RE.search(line)
+            if not m:
+                continue
+            var_name = m.group(1)
+
+            result.nodes.append(GraphNode(
+                id=f"{ctx.file_path}:export:{var_name}",
+                kind=NodeKind.CONFIG_DEFINITION,
+                label=f"export {var_name}",
+                fqn=var_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=i + 1,
+                ),
+            ))
+
+        # Detect infrastructure tool usage
+        tools_seen: set[str] = set()
+        for i, line in enumerate(lines):
+            # Skip comments
+            stripped = line.lstrip()
+            if stripped.startswith('#'):
+                continue
+            for m in _TOOL_RE.finditer(line):
+                tool = m.group(1)
+                if tool not in tools_seen:
+                    tools_seen.add(tool)
+                    result.edges.append(GraphEdge(
+                        source=ctx.file_path,
+                        target=tool,
+                        kind=EdgeKind.CALLS,
+                        label=f"{ctx.file_path} uses {tool}",
+                        properties={"tool": tool},
+                    ))
+
+        return result