blasttrace 1.2.0__py2.py3-none-any.whl

blasttrace/parsers/dart_flutter_parser.py

@@ -0,0 +1,110 @@
+"""
+BlastTrace Dart & Flutter Mobile/Client Parser
+Parses Dart models, fromJson/toJson serializers, and HTTP/Dio API route consumers
+in Flutter mobile, tablet, and POS applications.
+"""
+
+import os
+import re
+from typing import Dict, Any, List
+
+
+def _normalize_route_path(raw_url: str) -> str:
+    cleaned = raw_url.strip().strip("\"'`")
+    cleaned = re.sub(r"^https?://[^/]+", "", cleaned)
+    cleaned = cleaned.split("?")[0]
+    cleaned = re.sub(r"\$([a-zA-Z0-9_]+)", ":param", cleaned)
+    cleaned = re.sub(r"\$\{([^}]+)\}", ":param", cleaned)
+    if not cleaned.startswith("/"):
+        cleaned = "/" + cleaned
+    if len(cleaned) > 1 and cleaned.endswith("/"):
+        cleaned = cleaned.rstrip("/")
+    return cleaned
+
+
+def parse_dart_content(content: str, rel_path: str = "") -> Dict[str, Any]:
+    """
+    Extracts Flutter Dart classes, models, fromJson field accesses,
+    and HTTP API route consumer calls from Dart source code.
+    """
+    classes: List[Dict[str, Any]] = []
+    api_calls: List[Dict[str, Any]] = []
+    accessed_properties: List[str] = []
+
+    # 1. Parse Dart Classes and Models
+    class_regex = re.compile(r"class\s+([A-Za-z0-9_]+)(?:\s+extends\s+[A-Za-z0-9_]+)?\s*\{", re.MULTILINE)
+    for m in class_regex.finditer(content):
+        cname = m.group(1)
+        classes.append({
+            "name": cname,
+            "type": "dart_class",
+            "file": rel_path,
+            "line": content[:m.start()].count("\n") + 1,
+        })
+
+    # 2. Parse fromJson / JSON field deserialization: json['field_name'] or map['field_name']
+    json_field_regex = re.compile(r"(?:json|map|data)\[['\"]([a-zA-Z0-9_]+)['\"]\]")
+    for jm in json_field_regex.finditer(content):
+        field_name = jm.group(1)
+        if field_name not in accessed_properties:
+            accessed_properties.append(field_name)
+
+    # 3. Parse Dart field declarations: final String name; or int? quantity;
+    field_decl_regex = re.compile(r"^\s*(?:final\s+|const\s+)?(?:[A-Za-z0-9_<>?]+\s+)+([a-zA-Z0-9_]+)\s*;", re.MULTILINE)
+    for fm in field_decl_regex.finditer(content):
+        fname = fm.group(1)
+        if fname not in ("key", "super", "override", "build") and fname not in accessed_properties:
+            accessed_properties.append(fname)
+
+    # 4. Parse HTTP and Dio API calls:
+    # http.get(Uri.parse('...')), dio.get('...'), client.get('...'), api.get('...')
+    http_call_patterns = [
+        re.compile(r"""(?:http|client|dio|apiClient|api|service)\.(get|post|put|patch|delete)\s*\(\s*(?:Uri\.parse\s*\(\s*)?['"]([^'"]+)['"]""", re.IGNORECASE),
+        re.compile(r"""['"]((?:/api/v[0-9]+|/api/|/products|/sales|/sync|/orders|/users)[^'"]*)['"]"""),
+    ]
+
+    for m in http_call_patterns[0].finditer(content):
+        method = m.group(1).upper()
+        raw_url = m.group(2)
+        route_path = _normalize_route_path(raw_url)
+        api_calls.append({
+            "method": method,
+            "path": route_path,
+            "raw_url": raw_url,
+            "file": rel_path,
+            "line": content[:m.start()].count("\n") + 1,
+        })
+
+    for m in http_call_patterns[1].finditer(content):
+        raw_url = m.group(1)
+        route_path = _normalize_route_path(raw_url)
+        if not any(c["path"] == route_path for c in api_calls):
+            api_calls.append({
+                "method": "ANY",
+                "path": route_path,
+                "raw_url": raw_url,
+                "file": rel_path,
+                "line": content[:m.start()].count("\n") + 1,
+            })
+
+    return {
+        "file": rel_path,
+        "layer": "flutter_client",
+        "classes": classes,
+        "api_calls": api_calls,
+        "accessed_properties": accessed_properties,
+    }
+
+
+def parse_dart_file(file_path: str, repo_root: str = "") -> Dict[str, Any]:
+    if not os.path.exists(file_path):
+        return {"error": f"File not found: {file_path}"}
+    rel_path = os.path.relpath(file_path, repo_root) if repo_root else file_path
+    rel_path = rel_path.replace("\\", "/")
+    try:
+        with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+            content = f.read()
+        return parse_dart_content(content, rel_path)
+    except Exception as exc:
+        return {"error": str(exc), "file": rel_path}
+

blasttrace/parsers/go_parser.py

@@ -0,0 +1,196 @@
+"""
+BlastTrace Go (Golang) AST Parser
+Extracts Go structs, JSON / GORM field tags, REST API route handlers
+(Gin, Fiber, Chi, standard net/http), and outbound HTTP queries.
+"""
+
+import os
+import re
+from typing import Dict, Any, List, Optional, Set
+from dataclasses import dataclass, field
+
+
+@dataclass
+class GoField:
+    name: str
+    type_name: str
+    json_name: Optional[str] = None
+    gorm_tag: Optional[str] = None
+
+
+@dataclass
+class GoStruct:
+    name: str
+    file_path: str
+    fields: List[GoField] = field(default_factory=list)
+
+
+@dataclass
+class GoRoute:
+    method: str
+    path: str
+    handler_name: str
+    framework: str = "gin"  # gin, fiber, chi, net/http
+
+
+@dataclass
+class GoApiCall:
+    endpoint: str
+    method: str = "GET"
+    line_number: int = 1
+
+
+@dataclass
+class GoFunction:
+    name: str
+    receiver: Optional[str] = None
+    params: List[str] = field(default_factory=list)
+    return_types: List[str] = field(default_factory=list)
+
+
+@dataclass
+class GoParseResult:
+    structs: List[GoStruct] = field(default_factory=list)
+    routes: List[GoRoute] = field(default_factory=list)
+    api_calls: List[GoApiCall] = field(default_factory=list)
+    functions: List[GoFunction] = field(default_factory=list)
+
+
+# Struct regex
+_RE_STRUCT = re.compile(r"type\s+([A-Za-z0-9_]+)\s+struct\s*\{([^}]*)\}", re.DOTALL)
+_RE_STRUCT_FIELD = re.compile(r"([A-Za-z0-9_]+)\s+([A-Za-z0-9_\*\[\]\.\{\}]+)(?:\s+`([^`]*)`)?")
+
+# Route definitions
+# Gin: r.GET("/path", handler)
+_RE_GIN_ROUTE = re.compile(r"(?:[A-Za-z0-9_]+)\.(GET|POST|PUT|DELETE|PATCH)\(\s*['\"`](/[^'\"`]+)['\"`]\s*,\s*([A-Za-z0-9_\.]+)")
+# Fiber: app.Get("/path", handler)
+_RE_FIBER_ROUTE = re.compile(r"(?:[A-Za-z0-9_]+)\.(Get|Post|Put|Delete|Patch)\(\s*['\"`](/[^'\"`]+)['\"`]\s*,\s*([A-Za-z0-9_\.]+)")
+# Chi: r.Get("/path", handler)
+_RE_CHI_ROUTE = re.compile(r"(?:[A-Za-z0-9_]+)\.(Get|Post|Put|Delete|Patch|Handle|HandleFunc)\(\s*['\"`](/[^'\"`]+)['\"`]\s*,\s*([A-Za-z0-9_\.]+)")
+# net/http: http.HandleFunc("/path", handler)
+_RE_NETHTTP_ROUTE = re.compile(r"http\.HandleFunc\(\s*['\"`](/[^'\"`]+)['\"`]\s*,\s*([A-Za-z0-9_\.]+)")
+
+# Outbound HTTP calls in Go:
+# http.Get("url") or http.NewRequest("GET", "url")
+_RE_OUTBOUND_HTTP = re.compile(r"http\.(Get|Post)\(\s*['\"`]([^'\"`]+)['\"`]")
+_RE_NEW_REQUEST = re.compile(r"http\.NewRequest(?:WithContext)?\(\s*['\"`](GET|POST|PUT|DELETE|PATCH)['\"`]\s*,\s*['\"`]([^'\"`]+)['\"`]")
+
+# Function definition:
+# func (s *Service) GetUser(ctx context.Context, id int) (*User, error)
+_RE_FUNC = re.compile(r"func\s*(?:\(\s*([A-Za-z0-9_\*\s]+)\s*\))?\s*([A-Za-z0-9_]+)\s*\((.*?)\)(?:\s*(?:\((.*?)\)|([A-Za-z0-9_\*\.\[\]]+)))?")
+
+
+def _extract_json_tag(tag_str: str) -> Optional[str]:
+    if not tag_str:
+        return None
+    match = re.search(r'json:"([^",]+)', tag_str)
+    return match.group(1) if match else None
+
+
+def _extract_gorm_tag(tag_str: str) -> Optional[str]:
+    if not tag_str:
+        return None
+    match = re.search(r'gorm:"([^"]+)"', tag_str)
+    return match.group(1) if match else None
+
+
+def parse_go_content(content: str, file_path: str = "service.go") -> GoParseResult:
+    """Parses a Go source file (.go)."""
+    result = GoParseResult()
+
+    # 1. Parse Structs
+    for match in _RE_STRUCT.finditer(content):
+        struct_name = match.group(1)
+        body = match.group(2)
+        go_struct = GoStruct(name=struct_name, file_path=file_path)
+
+        for line in body.splitlines():
+            line = line.strip()
+            if not line or line.startswith("//"):
+                continue
+            fmatch = _RE_STRUCT_FIELD.match(line)
+            if fmatch:
+                fname = fmatch.group(1)
+                ftype = fmatch.group(2)
+                raw_tags = fmatch.group(3) or ""
+                jname = _extract_json_tag(raw_tags)
+                gtag = _extract_gorm_tag(raw_tags)
+                go_struct.fields.append(GoField(
+                    name=fname,
+                    type_name=ftype,
+                    json_name=jname,
+                    gorm_tag=gtag
+                ))
+        result.structs.append(go_struct)
+
+    # 2. Parse API Routes
+    # Gin
+    for match in _RE_GIN_ROUTE.finditer(content):
+        result.routes.append(GoRoute(
+            method=match.group(1).upper(),
+            path=match.group(2),
+            handler_name=match.group(3),
+            framework="gin"
+        ))
+    # Fiber
+    for match in _RE_FIBER_ROUTE.finditer(content):
+        result.routes.append(GoRoute(
+            method=match.group(1).upper(),
+            path=match.group(2),
+            handler_name=match.group(3),
+            framework="fiber"
+        ))
+    # Chi
+    for match in _RE_CHI_ROUTE.finditer(content):
+        result.routes.append(GoRoute(
+            method=match.group(1).upper(),
+            path=match.group(2),
+            handler_name=match.group(3),
+            framework="chi"
+        ))
+    # net/http
+    for match in _RE_NETHTTP_ROUTE.finditer(content):
+        result.routes.append(GoRoute(
+            method="ANY",
+            path=match.group(1),
+            handler_name=match.group(2),
+            framework="net/http"
+        ))
+
+    # 3. Parse Outbound HTTP Queries
+    for match in _RE_OUTBOUND_HTTP.finditer(content):
+        result.api_calls.append(GoApiCall(
+            method=match.group(1).upper(),
+            endpoint=match.group(2)
+        ))
+    for match in _RE_NEW_REQUEST.finditer(content):
+        result.api_calls.append(GoApiCall(
+            method=match.group(1).upper(),
+            endpoint=match.group(2)
+        ))
+
+    # 4. Parse Functions
+    for match in _RE_FUNC.finditer(content):
+        receiver = match.group(1).strip() if match.group(1) else None
+        fname = match.group(2)
+        raw_params = match.group(3) or ""
+        params = [p.strip() for p in raw_params.split(",") if p.strip()]
+        result.functions.append(GoFunction(
+            name=fname,
+            receiver=receiver,
+            params=params
+        ))
+
+    return result
+
+
+def parse_go_file(file_path: str) -> Optional[GoParseResult]:
+    """Reads and parses a .go file."""
+    if not os.path.exists(file_path):
+        return None
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            content = f.read()
+        return parse_go_content(content, file_path)
+    except Exception:
+        return None

blasttrace/parsers/kotlin_android_parser.py

@@ -0,0 +1,122 @@
+"""
+BlastTrace Kotlin & Android Mobile/Tablet Parser
+Parses Kotlin data classes, SerializedName annotations, Retrofit HTTP annotations,
+and OkHttp/Ktor client route consumers in native Android applications.
+"""
+
+import os
+import re
+from typing import Dict, Any, List
+
+
+def _normalize_route_path(raw_url: str) -> str:
+    cleaned = raw_url.strip().strip("\"'`")
+    cleaned = re.sub(r"^https?://[^/]+", "", cleaned)
+    cleaned = cleaned.split("?")[0]
+    cleaned = re.sub(r"\{[^}]+\}", ":param", cleaned)
+    cleaned = re.sub(r"\$([a-zA-Z0-9_]+)", ":param", cleaned)
+    if not cleaned.startswith("/"):
+        cleaned = "/" + cleaned
+    if len(cleaned) > 1 and cleaned.endswith("/"):
+        cleaned = cleaned.rstrip("/")
+    return cleaned
+
+
+def parse_kotlin_content(content: str, rel_path: str = "") -> Dict[str, Any]:
+    """
+    Extracts Kotlin data classes, Retrofit endpoints, SerializedName mappings,
+    and HTTP API calls from Android source code.
+    """
+    classes: List[Dict[str, Any]] = []
+    api_calls: List[Dict[str, Any]] = []
+    accessed_properties: List[str] = []
+
+    # 1. Parse Kotlin Data Classes and Classes: data class Product(...), class OrderResponse
+    class_regex = re.compile(
+        r"""(?:data\s+)?class\s+([A-Za-z0-9_]+)(?:\s*\(([^)]*)\))?""",
+        re.MULTILINE,
+    )
+    for m in class_regex.finditer(content):
+        cname = m.group(1)
+        params = m.group(2) or ""
+        classes.append({
+            "name": cname,
+            "type": "kotlin_model",
+            "file": rel_path,
+            "line": content[:m.start()].count("\n") + 1,
+        })
+        # Extract constructor properties inside data class (...)
+        for p in params.split(","):
+            p_clean = p.strip()
+            field_match = re.search(r"""(?:val|var)\s+([a-zA-Z0-9_]+)""", p_clean)
+            if field_match:
+                fname = field_match.group(1)
+                if fname not in accessed_properties:
+                    accessed_properties.append(fname)
+
+    # 2. Parse @SerializedName("field") or @SerialName("field")
+    ser_regex = re.compile(r"""@(?:SerializedName|SerialName|JsonProperty)\s*\(\s*["']([^"']+)["']\s*\)""")
+    for sm in ser_regex.finditer(content):
+        prop = sm.group(1)
+        if prop not in accessed_properties:
+            accessed_properties.append(prop)
+
+    # 3. Parse general property declarations: val balance: Double or var tier: String
+    prop_regex = re.compile(r"""(?:val|var)\s+([a-zA-Z0-9_]+)\s*:\s*[A-Za-z0-9_<>?]+""", re.MULTILINE)
+    for pm in prop_regex.finditer(content):
+        pname = pm.group(1)
+        if pname not in ("tag", "context", "binding", "viewModel", "compositeDisposable") and pname not in accessed_properties:
+            accessed_properties.append(pname)
+
+    # 4. Parse Retrofit API Interface annotations: @GET("/api/v1/..."), @POST("...")
+    retrofit_regex = re.compile(
+        r"""@(GET|POST|PUT|PATCH|DELETE)\s*\(\s*["']([^"']+)["']\s*\)""",
+        re.IGNORECASE,
+    )
+    for rm in retrofit_regex.finditer(content):
+        method = rm.group(1).upper()
+        raw_url = rm.group(2)
+        route_path = _normalize_route_path(raw_url)
+        api_calls.append({
+            "method": method,
+            "path": route_path,
+            "raw_url": raw_url,
+            "file": rel_path,
+            "line": content[:rm.start()].count("\n") + 1,
+        })
+
+    # 5. Parse Ktor / OkHttp / URL string literals
+    url_literal_regex = re.compile(r"""["']((?:/api/v[0-9]+|/api/|/products|/sales|/sync|/orders|/users)[^"']*)["']""")
+    for um in url_literal_regex.finditer(content):
+        raw_url = um.group(1)
+        route_path = _normalize_route_path(raw_url)
+        if not any(c["path"] == route_path for c in api_calls):
+            api_calls.append({
+                "method": "ANY",
+                "path": route_path,
+                "raw_url": raw_url,
+                "file": rel_path,
+                "line": content[:um.start()].count("\n") + 1,
+            })
+
+    return {
+        "file": rel_path,
+        "layer": "android_client",
+        "classes": classes,
+        "api_calls": api_calls,
+        "accessed_properties": accessed_properties,
+    }
+
+
+def parse_kotlin_file(file_path: str, repo_root: str = "") -> Dict[str, Any]:
+    if not os.path.exists(file_path):
+        return {"error": f"File not found: {file_path}"}
+    rel_path = os.path.relpath(file_path, repo_root) if repo_root else file_path
+    rel_path = rel_path.replace("\\", "/")
+    try:
+        with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+            content = f.read()
+        return parse_kotlin_content(content, rel_path)
+    except Exception as exc:
+        return {"error": str(exc), "file": rel_path}
+