Add DAST, graph modules, toast notifications, and dashboard enhancements
Add DAST scanning and code knowledge graph features across the stack: - compliance-dast and compliance-graph workspace crates - Agent API handlers and routes for DAST targets/scans and graph builds - Core models and traits for DAST and graph domains - Dashboard pages for DAST targets/findings/overview and graph explorer/impact - Toast notification system with auto-dismiss for async action feedback - Button click animations and disabled states for better UX Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Sharang Parnerkar
372
compliance-graph/src/parsers/javascript.rs
Normal file
372
compliance-graph/src/parsers/javascript.rs
Normal file
@@ -0,0 +1,372 @@
|
||||
use std::path::Path;
|
||||
|
||||
use compliance_core::error::CoreError;
|
||||
use compliance_core::models::graph::{CodeEdge, CodeEdgeKind, CodeNode, CodeNodeKind};
|
||||
use compliance_core::traits::graph_builder::{LanguageParser, ParseOutput};
|
||||
use tree_sitter::{Node, Parser};
|
||||
|
||||
pub struct JavaScriptParser;
|
||||
|
||||
impl JavaScriptParser {
|
||||
pub fn new() -> Self {
|
||||
Self
|
||||
}
|
||||
|
||||
fn walk_tree(
|
||||
&self,
|
||||
node: Node<'_>,
|
||||
source: &str,
|
||||
file_path: &str,
|
||||
repo_id: &str,
|
||||
graph_build_id: &str,
|
||||
parent_qualified: Option<&str>,
|
||||
output: &mut ParseOutput,
|
||||
) {
|
||||
match node.kind() {
|
||||
"function_declaration" => {
|
||||
if let Some(name_node) = node.child_by_field_name("name") {
|
||||
let name = &source[name_node.byte_range()];
|
||||
let qualified = match parent_qualified {
|
||||
Some(p) => format!("{p}.{name}"),
|
||||
None => format!("{file_path}::{name}"),
|
||||
};
|
||||
|
||||
let is_entry = self.is_exported_function(&node, source);
|
||||
|
||||
output.nodes.push(CodeNode {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
qualified_name: qualified.clone(),
|
||||
name: name.to_string(),
|
||||
kind: CodeNodeKind::Function,
|
||||
file_path: file_path.to_string(),
|
||||
start_line: node.start_position().row as u32 + 1,
|
||||
end_line: node.end_position().row as u32 + 1,
|
||||
language: "javascript".to_string(),
|
||||
community_id: None,
|
||||
is_entry_point: is_entry,
|
||||
graph_index: None,
|
||||
});
|
||||
|
||||
if let Some(body) = node.child_by_field_name("body") {
|
||||
self.extract_calls(
|
||||
body, source, file_path, repo_id, graph_build_id, &qualified, output,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
"class_declaration" => {
|
||||
if let Some(name_node) = node.child_by_field_name("name") {
|
||||
let name = &source[name_node.byte_range()];
|
||||
let qualified = match parent_qualified {
|
||||
Some(p) => format!("{p}.{name}"),
|
||||
None => format!("{file_path}::{name}"),
|
||||
};
|
||||
|
||||
output.nodes.push(CodeNode {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
qualified_name: qualified.clone(),
|
||||
name: name.to_string(),
|
||||
kind: CodeNodeKind::Class,
|
||||
file_path: file_path.to_string(),
|
||||
start_line: node.start_position().row as u32 + 1,
|
||||
end_line: node.end_position().row as u32 + 1,
|
||||
language: "javascript".to_string(),
|
||||
community_id: None,
|
||||
is_entry_point: false,
|
||||
graph_index: None,
|
||||
});
|
||||
|
||||
// Extract superclass
|
||||
if let Some(heritage) = node.child_by_field_name("superclass") {
|
||||
let base_name = &source[heritage.byte_range()];
|
||||
output.edges.push(CodeEdge {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
source: qualified.clone(),
|
||||
target: base_name.to_string(),
|
||||
kind: CodeEdgeKind::Inherits,
|
||||
file_path: file_path.to_string(),
|
||||
line_number: Some(node.start_position().row as u32 + 1),
|
||||
});
|
||||
}
|
||||
|
||||
if let Some(body) = node.child_by_field_name("body") {
|
||||
self.walk_children(
|
||||
body, source, file_path, repo_id, graph_build_id, Some(&qualified),
|
||||
output,
|
||||
);
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
"method_definition" => {
|
||||
if let Some(name_node) = node.child_by_field_name("name") {
|
||||
let name = &source[name_node.byte_range()];
|
||||
let qualified = match parent_qualified {
|
||||
Some(p) => format!("{p}.{name}"),
|
||||
None => format!("{file_path}::{name}"),
|
||||
};
|
||||
|
||||
output.nodes.push(CodeNode {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
qualified_name: qualified.clone(),
|
||||
name: name.to_string(),
|
||||
kind: CodeNodeKind::Method,
|
||||
file_path: file_path.to_string(),
|
||||
start_line: node.start_position().row as u32 + 1,
|
||||
end_line: node.end_position().row as u32 + 1,
|
||||
language: "javascript".to_string(),
|
||||
community_id: None,
|
||||
is_entry_point: false,
|
||||
graph_index: None,
|
||||
});
|
||||
|
||||
if let Some(body) = node.child_by_field_name("body") {
|
||||
self.extract_calls(
|
||||
body, source, file_path, repo_id, graph_build_id, &qualified, output,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
// Arrow functions assigned to variables: const foo = () => {}
|
||||
"lexical_declaration" | "variable_declaration" => {
|
||||
self.extract_arrow_functions(
|
||||
node, source, file_path, repo_id, graph_build_id, parent_qualified, output,
|
||||
);
|
||||
}
|
||||
"import_statement" => {
|
||||
let text = &source[node.byte_range()];
|
||||
if let Some(module) = self.extract_import_source(text) {
|
||||
output.edges.push(CodeEdge {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
source: parent_qualified.unwrap_or(file_path).to_string(),
|
||||
target: module,
|
||||
kind: CodeEdgeKind::Imports,
|
||||
file_path: file_path.to_string(),
|
||||
line_number: Some(node.start_position().row as u32 + 1),
|
||||
});
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
|
||||
self.walk_children(
|
||||
node,
|
||||
source,
|
||||
file_path,
|
||||
repo_id,
|
||||
graph_build_id,
|
||||
parent_qualified,
|
||||
output,
|
||||
);
|
||||
}
|
||||
|
||||
fn walk_children(
|
||||
&self,
|
||||
node: Node<'_>,
|
||||
source: &str,
|
||||
file_path: &str,
|
||||
repo_id: &str,
|
||||
graph_build_id: &str,
|
||||
parent_qualified: Option<&str>,
|
||||
output: &mut ParseOutput,
|
||||
) {
|
||||
let mut cursor = node.walk();
|
||||
for child in node.children(&mut cursor) {
|
||||
self.walk_tree(
|
||||
child, source, file_path, repo_id, graph_build_id, parent_qualified, output,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
fn extract_calls(
|
||||
&self,
|
||||
node: Node<'_>,
|
||||
source: &str,
|
||||
file_path: &str,
|
||||
repo_id: &str,
|
||||
graph_build_id: &str,
|
||||
caller_qualified: &str,
|
||||
output: &mut ParseOutput,
|
||||
) {
|
||||
if node.kind() == "call_expression" {
|
||||
if let Some(func_node) = node.child_by_field_name("function") {
|
||||
let callee = &source[func_node.byte_range()];
|
||||
output.edges.push(CodeEdge {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
source: caller_qualified.to_string(),
|
||||
target: callee.to_string(),
|
||||
kind: CodeEdgeKind::Calls,
|
||||
file_path: file_path.to_string(),
|
||||
line_number: Some(node.start_position().row as u32 + 1),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
let mut cursor = node.walk();
|
||||
for child in node.children(&mut cursor) {
|
||||
self.extract_calls(
|
||||
child, source, file_path, repo_id, graph_build_id, caller_qualified, output,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
fn extract_arrow_functions(
|
||||
&self,
|
||||
node: Node<'_>,
|
||||
source: &str,
|
||||
file_path: &str,
|
||||
repo_id: &str,
|
||||
graph_build_id: &str,
|
||||
parent_qualified: Option<&str>,
|
||||
output: &mut ParseOutput,
|
||||
) {
|
||||
let mut cursor = node.walk();
|
||||
for child in node.children(&mut cursor) {
|
||||
if child.kind() == "variable_declarator" {
|
||||
let name_node = child.child_by_field_name("name");
|
||||
let value_node = child.child_by_field_name("value");
|
||||
if let (Some(name_n), Some(value_n)) = (name_node, value_node) {
|
||||
if value_n.kind() == "arrow_function" || value_n.kind() == "function" {
|
||||
let name = &source[name_n.byte_range()];
|
||||
let qualified = match parent_qualified {
|
||||
Some(p) => format!("{p}.{name}"),
|
||||
None => format!("{file_path}::{name}"),
|
||||
};
|
||||
|
||||
output.nodes.push(CodeNode {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
qualified_name: qualified.clone(),
|
||||
name: name.to_string(),
|
||||
kind: CodeNodeKind::Function,
|
||||
file_path: file_path.to_string(),
|
||||
start_line: child.start_position().row as u32 + 1,
|
||||
end_line: child.end_position().row as u32 + 1,
|
||||
language: "javascript".to_string(),
|
||||
community_id: None,
|
||||
is_entry_point: false,
|
||||
graph_index: None,
|
||||
});
|
||||
|
||||
if let Some(body) = value_n.child_by_field_name("body") {
|
||||
self.extract_calls(
|
||||
body, source, file_path, repo_id, graph_build_id, &qualified,
|
||||
output,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn is_exported_function(&self, node: &Node<'_>, source: &str) -> bool {
|
||||
if let Some(parent) = node.parent() {
|
||||
if parent.kind() == "export_statement" {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
// Check for module.exports patterns
|
||||
if let Some(prev) = node.prev_sibling() {
|
||||
let text = &source[prev.byte_range()];
|
||||
if text.contains("module.exports") || text.contains("exports.") {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
fn extract_import_source(&self, import_text: &str) -> Option<String> {
|
||||
// import ... from 'module' or import 'module'
|
||||
let from_idx = import_text.find("from ");
|
||||
let start = if let Some(idx) = from_idx {
|
||||
idx + 5
|
||||
} else {
|
||||
import_text.find("import ")? + 7
|
||||
};
|
||||
let rest = &import_text[start..];
|
||||
let module = rest
|
||||
.trim()
|
||||
.trim_matches(|c| c == '\'' || c == '"' || c == ';' || c == ' ');
|
||||
if module.is_empty() {
|
||||
None
|
||||
} else {
|
||||
Some(module.to_string())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl LanguageParser for JavaScriptParser {
|
||||
fn language(&self) -> &str {
|
||||
"javascript"
|
||||
}
|
||||
|
||||
fn extensions(&self) -> &[&str] {
|
||||
&["js", "jsx", "mjs", "cjs"]
|
||||
}
|
||||
|
||||
fn parse_file(
|
||||
&self,
|
||||
file_path: &Path,
|
||||
source: &str,
|
||||
repo_id: &str,
|
||||
graph_build_id: &str,
|
||||
) -> Result<ParseOutput, CoreError> {
|
||||
let mut parser = Parser::new();
|
||||
let language = tree_sitter_javascript::LANGUAGE;
|
||||
parser
|
||||
.set_language(&language.into())
|
||||
.map_err(|e| CoreError::Graph(format!("Failed to set JavaScript language: {e}")))?;
|
||||
|
||||
let tree = parser
|
||||
.parse(source, None)
|
||||
.ok_or_else(|| CoreError::Graph("Failed to parse JavaScript file".to_string()))?;
|
||||
|
||||
let file_path_str = file_path.to_string_lossy().to_string();
|
||||
let mut output = ParseOutput::default();
|
||||
|
||||
output.nodes.push(CodeNode {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
qualified_name: file_path_str.clone(),
|
||||
name: file_path
|
||||
.file_name()
|
||||
.map(|n| n.to_string_lossy().to_string())
|
||||
.unwrap_or_default(),
|
||||
kind: CodeNodeKind::File,
|
||||
file_path: file_path_str.clone(),
|
||||
start_line: 1,
|
||||
end_line: source.lines().count() as u32,
|
||||
language: "javascript".to_string(),
|
||||
community_id: None,
|
||||
is_entry_point: false,
|
||||
graph_index: None,
|
||||
});
|
||||
|
||||
self.walk_tree(
|
||||
tree.root_node(),
|
||||
source,
|
||||
&file_path_str,
|
||||
repo_id,
|
||||
graph_build_id,
|
||||
None,
|
||||
&mut output,
|
||||
);
|
||||
|
||||
Ok(output)
|
||||
}
|
||||
}
|
||||
5
compliance-graph/src/parsers/mod.rs
Normal file
5
compliance-graph/src/parsers/mod.rs
Normal file
@@ -0,0 +1,5 @@
|
||||
pub mod javascript;
|
||||
pub mod python;
|
||||
pub mod registry;
|
||||
pub mod rust_parser;
|
||||
pub mod typescript;
|
||||
336
compliance-graph/src/parsers/python.rs
Normal file
336
compliance-graph/src/parsers/python.rs
Normal file
@@ -0,0 +1,336 @@
|
||||
use std::path::Path;
|
||||
|
||||
use compliance_core::error::CoreError;
|
||||
use compliance_core::models::graph::{CodeEdge, CodeEdgeKind, CodeNode, CodeNodeKind};
|
||||
use compliance_core::traits::graph_builder::{LanguageParser, ParseOutput};
|
||||
use tree_sitter::{Node, Parser};
|
||||
|
||||
pub struct PythonParser;
|
||||
|
||||
impl PythonParser {
|
||||
pub fn new() -> Self {
|
||||
Self
|
||||
}
|
||||
|
||||
fn walk_tree(
|
||||
&self,
|
||||
node: Node<'_>,
|
||||
source: &str,
|
||||
file_path: &str,
|
||||
repo_id: &str,
|
||||
graph_build_id: &str,
|
||||
parent_qualified: Option<&str>,
|
||||
output: &mut ParseOutput,
|
||||
) {
|
||||
match node.kind() {
|
||||
"function_definition" => {
|
||||
if let Some(name_node) = node.child_by_field_name("name") {
|
||||
let name = &source[name_node.byte_range()];
|
||||
let qualified = match parent_qualified {
|
||||
Some(p) => format!("{p}.{name}"),
|
||||
None => format!("{file_path}::{name}"),
|
||||
};
|
||||
|
||||
let is_method = parent_qualified
|
||||
.map(|p| p.contains("class"))
|
||||
.unwrap_or(false);
|
||||
let kind = if is_method {
|
||||
CodeNodeKind::Method
|
||||
} else {
|
||||
CodeNodeKind::Function
|
||||
};
|
||||
|
||||
let is_entry = name == "__main__"
|
||||
|| name == "main"
|
||||
|| self.has_decorator(&node, source, "app.route")
|
||||
|| self.has_decorator(&node, source, "app.get")
|
||||
|| self.has_decorator(&node, source, "app.post");
|
||||
|
||||
output.nodes.push(CodeNode {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
qualified_name: qualified.clone(),
|
||||
name: name.to_string(),
|
||||
kind,
|
||||
file_path: file_path.to_string(),
|
||||
start_line: node.start_position().row as u32 + 1,
|
||||
end_line: node.end_position().row as u32 + 1,
|
||||
language: "python".to_string(),
|
||||
community_id: None,
|
||||
is_entry_point: is_entry,
|
||||
graph_index: None,
|
||||
});
|
||||
|
||||
// Extract calls in function body
|
||||
if let Some(body) = node.child_by_field_name("body") {
|
||||
self.extract_calls(
|
||||
body,
|
||||
source,
|
||||
file_path,
|
||||
repo_id,
|
||||
graph_build_id,
|
||||
&qualified,
|
||||
output,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
"class_definition" => {
|
||||
if let Some(name_node) = node.child_by_field_name("name") {
|
||||
let name = &source[name_node.byte_range()];
|
||||
let qualified = match parent_qualified {
|
||||
Some(p) => format!("{p}.{name}"),
|
||||
None => format!("{file_path}::{name}"),
|
||||
};
|
||||
|
||||
output.nodes.push(CodeNode {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
qualified_name: qualified.clone(),
|
||||
name: name.to_string(),
|
||||
kind: CodeNodeKind::Class,
|
||||
file_path: file_path.to_string(),
|
||||
start_line: node.start_position().row as u32 + 1,
|
||||
end_line: node.end_position().row as u32 + 1,
|
||||
language: "python".to_string(),
|
||||
community_id: None,
|
||||
is_entry_point: false,
|
||||
graph_index: None,
|
||||
});
|
||||
|
||||
// Extract superclasses
|
||||
if let Some(bases) = node.child_by_field_name("superclasses") {
|
||||
self.extract_inheritance(
|
||||
bases,
|
||||
source,
|
||||
file_path,
|
||||
repo_id,
|
||||
graph_build_id,
|
||||
&qualified,
|
||||
output,
|
||||
);
|
||||
}
|
||||
|
||||
// Walk methods
|
||||
if let Some(body) = node.child_by_field_name("body") {
|
||||
self.walk_children(
|
||||
body,
|
||||
source,
|
||||
file_path,
|
||||
repo_id,
|
||||
graph_build_id,
|
||||
Some(&qualified),
|
||||
output,
|
||||
);
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
"import_statement" | "import_from_statement" => {
|
||||
let import_text = &source[node.byte_range()];
|
||||
if let Some(module) = self.extract_import_module(import_text) {
|
||||
output.edges.push(CodeEdge {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
source: parent_qualified.unwrap_or(file_path).to_string(),
|
||||
target: module,
|
||||
kind: CodeEdgeKind::Imports,
|
||||
file_path: file_path.to_string(),
|
||||
line_number: Some(node.start_position().row as u32 + 1),
|
||||
});
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
|
||||
self.walk_children(
|
||||
node,
|
||||
source,
|
||||
file_path,
|
||||
repo_id,
|
||||
graph_build_id,
|
||||
parent_qualified,
|
||||
output,
|
||||
);
|
||||
}
|
||||
|
||||
fn walk_children(
|
||||
&self,
|
||||
node: Node<'_>,
|
||||
source: &str,
|
||||
file_path: &str,
|
||||
repo_id: &str,
|
||||
graph_build_id: &str,
|
||||
parent_qualified: Option<&str>,
|
||||
output: &mut ParseOutput,
|
||||
) {
|
||||
let mut cursor = node.walk();
|
||||
for child in node.children(&mut cursor) {
|
||||
self.walk_tree(
|
||||
child,
|
||||
source,
|
||||
file_path,
|
||||
repo_id,
|
||||
graph_build_id,
|
||||
parent_qualified,
|
||||
output,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
fn extract_calls(
|
||||
&self,
|
||||
node: Node<'_>,
|
||||
source: &str,
|
||||
file_path: &str,
|
||||
repo_id: &str,
|
||||
graph_build_id: &str,
|
||||
caller_qualified: &str,
|
||||
output: &mut ParseOutput,
|
||||
) {
|
||||
if node.kind() == "call" {
|
||||
if let Some(func_node) = node.child_by_field_name("function") {
|
||||
let callee = &source[func_node.byte_range()];
|
||||
output.edges.push(CodeEdge {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
source: caller_qualified.to_string(),
|
||||
target: callee.to_string(),
|
||||
kind: CodeEdgeKind::Calls,
|
||||
file_path: file_path.to_string(),
|
||||
line_number: Some(node.start_position().row as u32 + 1),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
let mut cursor = node.walk();
|
||||
for child in node.children(&mut cursor) {
|
||||
self.extract_calls(
|
||||
child,
|
||||
source,
|
||||
file_path,
|
||||
repo_id,
|
||||
graph_build_id,
|
||||
caller_qualified,
|
||||
output,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
fn extract_inheritance(
|
||||
&self,
|
||||
node: Node<'_>,
|
||||
source: &str,
|
||||
file_path: &str,
|
||||
repo_id: &str,
|
||||
graph_build_id: &str,
|
||||
class_qualified: &str,
|
||||
output: &mut ParseOutput,
|
||||
) {
|
||||
let mut cursor = node.walk();
|
||||
for child in node.children(&mut cursor) {
|
||||
if child.kind() == "identifier" || child.kind() == "attribute" {
|
||||
let base_name = &source[child.byte_range()];
|
||||
output.edges.push(CodeEdge {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
source: class_qualified.to_string(),
|
||||
target: base_name.to_string(),
|
||||
kind: CodeEdgeKind::Inherits,
|
||||
file_path: file_path.to_string(),
|
||||
line_number: Some(node.start_position().row as u32 + 1),
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn has_decorator(&self, node: &Node<'_>, source: &str, decorator_name: &str) -> bool {
|
||||
if let Some(prev) = node.prev_sibling() {
|
||||
if prev.kind() == "decorator" {
|
||||
let text = &source[prev.byte_range()];
|
||||
return text.contains(decorator_name);
|
||||
}
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
fn extract_import_module(&self, import_text: &str) -> Option<String> {
|
||||
if let Some(rest) = import_text.strip_prefix("from ") {
|
||||
// "from foo.bar import baz" -> "foo.bar"
|
||||
let module = rest.split_whitespace().next()?;
|
||||
Some(module.to_string())
|
||||
} else if let Some(rest) = import_text.strip_prefix("import ") {
|
||||
let module = rest.trim().trim_end_matches(';');
|
||||
Some(module.to_string())
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl LanguageParser for PythonParser {
|
||||
fn language(&self) -> &str {
|
||||
"python"
|
||||
}
|
||||
|
||||
fn extensions(&self) -> &[&str] {
|
||||
&["py"]
|
||||
}
|
||||
|
||||
fn parse_file(
|
||||
&self,
|
||||
file_path: &Path,
|
||||
source: &str,
|
||||
repo_id: &str,
|
||||
graph_build_id: &str,
|
||||
) -> Result<ParseOutput, CoreError> {
|
||||
let mut parser = Parser::new();
|
||||
let language = tree_sitter_python::LANGUAGE;
|
||||
parser
|
||||
.set_language(&language.into())
|
||||
.map_err(|e| CoreError::Graph(format!("Failed to set Python language: {e}")))?;
|
||||
|
||||
let tree = parser
|
||||
.parse(source, None)
|
||||
.ok_or_else(|| CoreError::Graph("Failed to parse Python file".to_string()))?;
|
||||
|
||||
let file_path_str = file_path.to_string_lossy().to_string();
|
||||
let mut output = ParseOutput::default();
|
||||
|
||||
output.nodes.push(CodeNode {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
qualified_name: file_path_str.clone(),
|
||||
name: file_path
|
||||
.file_name()
|
||||
.map(|n| n.to_string_lossy().to_string())
|
||||
.unwrap_or_default(),
|
||||
kind: CodeNodeKind::File,
|
||||
file_path: file_path_str.clone(),
|
||||
start_line: 1,
|
||||
end_line: source.lines().count() as u32,
|
||||
language: "python".to_string(),
|
||||
community_id: None,
|
||||
is_entry_point: false,
|
||||
graph_index: None,
|
||||
});
|
||||
|
||||
self.walk_tree(
|
||||
tree.root_node(),
|
||||
source,
|
||||
&file_path_str,
|
||||
repo_id,
|
||||
graph_build_id,
|
||||
None,
|
||||
&mut output,
|
||||
);
|
||||
|
||||
Ok(output)
|
||||
}
|
||||
}
|
||||
182
compliance-graph/src/parsers/registry.rs
Normal file
182
compliance-graph/src/parsers/registry.rs
Normal file
@@ -0,0 +1,182 @@
|
||||
use std::collections::HashMap;
|
||||
use std::path::Path;
|
||||
|
||||
use compliance_core::error::CoreError;
|
||||
use compliance_core::traits::graph_builder::{LanguageParser, ParseOutput};
|
||||
use tracing::info;
|
||||
|
||||
use super::javascript::JavaScriptParser;
|
||||
use super::python::PythonParser;
|
||||
use super::rust_parser::RustParser;
|
||||
use super::typescript::TypeScriptParser;
|
||||
|
||||
/// Registry of language parsers, indexed by file extension
|
||||
pub struct ParserRegistry {
|
||||
parsers: Vec<Box<dyn LanguageParser>>,
|
||||
extension_map: HashMap<String, usize>,
|
||||
}
|
||||
|
||||
impl ParserRegistry {
|
||||
/// Create a registry with all built-in parsers
|
||||
pub fn new() -> Self {
|
||||
let parsers: Vec<Box<dyn LanguageParser>> = vec![
|
||||
Box::new(RustParser::new()),
|
||||
Box::new(PythonParser::new()),
|
||||
Box::new(JavaScriptParser::new()),
|
||||
Box::new(TypeScriptParser::new()),
|
||||
];
|
||||
|
||||
let mut extension_map = HashMap::new();
|
||||
for (idx, parser) in parsers.iter().enumerate() {
|
||||
for ext in parser.extensions() {
|
||||
extension_map.insert(ext.to_string(), idx);
|
||||
}
|
||||
}
|
||||
|
||||
Self {
|
||||
parsers,
|
||||
extension_map,
|
||||
}
|
||||
}
|
||||
|
||||
/// Check if a file extension is supported
|
||||
pub fn supports_extension(&self, ext: &str) -> bool {
|
||||
self.extension_map.contains_key(ext)
|
||||
}
|
||||
|
||||
/// Get supported extensions
|
||||
pub fn supported_extensions(&self) -> Vec<&str> {
|
||||
self.extension_map.keys().map(|s| s.as_str()).collect()
|
||||
}
|
||||
|
||||
/// Parse a file, selecting the appropriate parser by extension
|
||||
pub fn parse_file(
|
||||
&self,
|
||||
file_path: &Path,
|
||||
source: &str,
|
||||
repo_id: &str,
|
||||
graph_build_id: &str,
|
||||
) -> Result<Option<ParseOutput>, CoreError> {
|
||||
let ext = file_path
|
||||
.extension()
|
||||
.and_then(|e| e.to_str())
|
||||
.unwrap_or("");
|
||||
|
||||
let parser_idx = match self.extension_map.get(ext) {
|
||||
Some(idx) => *idx,
|
||||
None => return Ok(None),
|
||||
};
|
||||
|
||||
let parser = &self.parsers[parser_idx];
|
||||
info!(
|
||||
file = %file_path.display(),
|
||||
language = parser.language(),
|
||||
"Parsing file"
|
||||
);
|
||||
|
||||
let output = parser.parse_file(file_path, source, repo_id, graph_build_id)?;
|
||||
Ok(Some(output))
|
||||
}
|
||||
|
||||
/// Parse all supported files in a directory tree
|
||||
pub fn parse_directory(
|
||||
&self,
|
||||
dir: &Path,
|
||||
repo_id: &str,
|
||||
graph_build_id: &str,
|
||||
max_nodes: u32,
|
||||
) -> Result<ParseOutput, CoreError> {
|
||||
let mut combined = ParseOutput::default();
|
||||
let mut node_count: u32 = 0;
|
||||
|
||||
self.walk_directory(dir, dir, repo_id, graph_build_id, max_nodes, &mut node_count, &mut combined)?;
|
||||
|
||||
info!(
|
||||
nodes = combined.nodes.len(),
|
||||
edges = combined.edges.len(),
|
||||
"Directory parsing complete"
|
||||
);
|
||||
|
||||
Ok(combined)
|
||||
}
|
||||
|
||||
fn walk_directory(
|
||||
&self,
|
||||
base: &Path,
|
||||
dir: &Path,
|
||||
repo_id: &str,
|
||||
graph_build_id: &str,
|
||||
max_nodes: u32,
|
||||
node_count: &mut u32,
|
||||
combined: &mut ParseOutput,
|
||||
) -> Result<(), CoreError> {
|
||||
let entries = std::fs::read_dir(dir).map_err(|e| {
|
||||
CoreError::Graph(format!("Failed to read directory {}: {e}", dir.display()))
|
||||
})?;
|
||||
|
||||
for entry in entries {
|
||||
let entry = entry.map_err(|e| CoreError::Graph(format!("Dir entry error: {e}")))?;
|
||||
let path = entry.path();
|
||||
|
||||
// Skip hidden directories and common non-source dirs
|
||||
if let Some(name) = path.file_name().and_then(|n| n.to_str()) {
|
||||
if name.starts_with('.')
|
||||
|| name == "node_modules"
|
||||
|| name == "target"
|
||||
|| name == "__pycache__"
|
||||
|| name == "vendor"
|
||||
|| name == "dist"
|
||||
|| name == "build"
|
||||
|| name == ".git"
|
||||
{
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
if path.is_dir() {
|
||||
self.walk_directory(
|
||||
base,
|
||||
&path,
|
||||
repo_id,
|
||||
graph_build_id,
|
||||
max_nodes,
|
||||
node_count,
|
||||
combined,
|
||||
)?;
|
||||
} else if path.is_file() {
|
||||
if *node_count >= max_nodes {
|
||||
info!(max_nodes, "Reached node limit, stopping parse");
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let ext = path.extension().and_then(|e| e.to_str()).unwrap_or("");
|
||||
if !self.supports_extension(ext) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Use relative path from base
|
||||
let rel_path = path.strip_prefix(base).unwrap_or(&path);
|
||||
|
||||
let source = match std::fs::read_to_string(&path) {
|
||||
Ok(s) => s,
|
||||
Err(_) => continue, // Skip binary/unreadable files
|
||||
};
|
||||
|
||||
if let Some(output) = self.parse_file(rel_path, &source, repo_id, graph_build_id)?
|
||||
{
|
||||
*node_count += output.nodes.len() as u32;
|
||||
combined.nodes.extend(output.nodes);
|
||||
combined.edges.extend(output.edges);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for ParserRegistry {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
}
|
||||
}
|
||||
426
compliance-graph/src/parsers/rust_parser.rs
Normal file
426
compliance-graph/src/parsers/rust_parser.rs
Normal file
@@ -0,0 +1,426 @@
|
||||
use std::path::Path;
|
||||
|
||||
use compliance_core::error::CoreError;
|
||||
use compliance_core::models::graph::{CodeEdge, CodeEdgeKind, CodeNode, CodeNodeKind};
|
||||
use compliance_core::traits::graph_builder::{LanguageParser, ParseOutput};
|
||||
use tree_sitter::{Node, Parser};
|
||||
|
||||
pub struct RustParser;
|
||||
|
||||
impl RustParser {
|
||||
pub fn new() -> Self {
|
||||
Self
|
||||
}
|
||||
|
||||
fn walk_tree(
|
||||
&self,
|
||||
node: Node<'_>,
|
||||
source: &str,
|
||||
file_path: &str,
|
||||
repo_id: &str,
|
||||
graph_build_id: &str,
|
||||
parent_qualified: Option<&str>,
|
||||
output: &mut ParseOutput,
|
||||
) {
|
||||
match node.kind() {
|
||||
"function_item" | "function_signature_item" => {
|
||||
if let Some(name_node) = node.child_by_field_name("name") {
|
||||
let name = &source[name_node.byte_range()];
|
||||
let qualified = match parent_qualified {
|
||||
Some(p) => format!("{p}::{name}"),
|
||||
None => format!("{file_path}::{name}"),
|
||||
};
|
||||
|
||||
let is_entry = name == "main"
|
||||
|| self.has_attribute(&node, source, "test")
|
||||
|| self.has_attribute(&node, source, "tokio::main")
|
||||
|| self.has_pub_visibility(&node, source);
|
||||
|
||||
output.nodes.push(CodeNode {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
qualified_name: qualified.clone(),
|
||||
name: name.to_string(),
|
||||
kind: CodeNodeKind::Function,
|
||||
file_path: file_path.to_string(),
|
||||
start_line: node.start_position().row as u32 + 1,
|
||||
end_line: node.end_position().row as u32 + 1,
|
||||
language: "rust".to_string(),
|
||||
community_id: None,
|
||||
is_entry_point: is_entry,
|
||||
graph_index: None,
|
||||
});
|
||||
|
||||
// Extract function calls within the body
|
||||
if let Some(body) = node.child_by_field_name("body") {
|
||||
self.extract_calls(
|
||||
body,
|
||||
source,
|
||||
file_path,
|
||||
repo_id,
|
||||
graph_build_id,
|
||||
&qualified,
|
||||
output,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
"struct_item" => {
|
||||
if let Some(name_node) = node.child_by_field_name("name") {
|
||||
let name = &source[name_node.byte_range()];
|
||||
let qualified = match parent_qualified {
|
||||
Some(p) => format!("{p}::{name}"),
|
||||
None => format!("{file_path}::{name}"),
|
||||
};
|
||||
|
||||
output.nodes.push(CodeNode {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
qualified_name: qualified,
|
||||
name: name.to_string(),
|
||||
kind: CodeNodeKind::Struct,
|
||||
file_path: file_path.to_string(),
|
||||
start_line: node.start_position().row as u32 + 1,
|
||||
end_line: node.end_position().row as u32 + 1,
|
||||
language: "rust".to_string(),
|
||||
community_id: None,
|
||||
is_entry_point: false,
|
||||
graph_index: None,
|
||||
});
|
||||
}
|
||||
}
|
||||
"enum_item" => {
|
||||
if let Some(name_node) = node.child_by_field_name("name") {
|
||||
let name = &source[name_node.byte_range()];
|
||||
let qualified = match parent_qualified {
|
||||
Some(p) => format!("{p}::{name}"),
|
||||
None => format!("{file_path}::{name}"),
|
||||
};
|
||||
|
||||
output.nodes.push(CodeNode {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
qualified_name: qualified,
|
||||
name: name.to_string(),
|
||||
kind: CodeNodeKind::Enum,
|
||||
file_path: file_path.to_string(),
|
||||
start_line: node.start_position().row as u32 + 1,
|
||||
end_line: node.end_position().row as u32 + 1,
|
||||
language: "rust".to_string(),
|
||||
community_id: None,
|
||||
is_entry_point: false,
|
||||
graph_index: None,
|
||||
});
|
||||
}
|
||||
}
|
||||
"trait_item" => {
|
||||
if let Some(name_node) = node.child_by_field_name("name") {
|
||||
let name = &source[name_node.byte_range()];
|
||||
let qualified = match parent_qualified {
|
||||
Some(p) => format!("{p}::{name}"),
|
||||
None => format!("{file_path}::{name}"),
|
||||
};
|
||||
|
||||
output.nodes.push(CodeNode {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
qualified_name: qualified.clone(),
|
||||
name: name.to_string(),
|
||||
kind: CodeNodeKind::Trait,
|
||||
file_path: file_path.to_string(),
|
||||
start_line: node.start_position().row as u32 + 1,
|
||||
end_line: node.end_position().row as u32 + 1,
|
||||
language: "rust".to_string(),
|
||||
community_id: None,
|
||||
is_entry_point: false,
|
||||
graph_index: None,
|
||||
});
|
||||
|
||||
// Parse methods inside the trait
|
||||
self.walk_children(
|
||||
node,
|
||||
source,
|
||||
file_path,
|
||||
repo_id,
|
||||
graph_build_id,
|
||||
Some(&qualified),
|
||||
output,
|
||||
);
|
||||
return; // Don't walk children again
|
||||
}
|
||||
}
|
||||
"impl_item" => {
|
||||
// Extract impl target type for qualified naming
|
||||
let impl_name = self.extract_impl_type(&node, source);
|
||||
let qualified = match parent_qualified {
|
||||
Some(p) => format!("{p}::{impl_name}"),
|
||||
None => format!("{file_path}::{impl_name}"),
|
||||
};
|
||||
|
||||
// Check for trait impl (impl Trait for Type)
|
||||
if let Some(trait_node) = node.child_by_field_name("trait") {
|
||||
let trait_name = &source[trait_node.byte_range()];
|
||||
output.edges.push(CodeEdge {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
source: qualified.clone(),
|
||||
target: trait_name.to_string(),
|
||||
kind: CodeEdgeKind::Implements,
|
||||
file_path: file_path.to_string(),
|
||||
line_number: Some(node.start_position().row as u32 + 1),
|
||||
});
|
||||
}
|
||||
|
||||
// Walk methods inside impl block
|
||||
self.walk_children(
|
||||
node,
|
||||
source,
|
||||
file_path,
|
||||
repo_id,
|
||||
graph_build_id,
|
||||
Some(&qualified),
|
||||
output,
|
||||
);
|
||||
return;
|
||||
}
|
||||
"use_declaration" => {
|
||||
let use_text = &source[node.byte_range()];
|
||||
// Extract the imported path
|
||||
if let Some(path) = self.extract_use_path(use_text) {
|
||||
output.edges.push(CodeEdge {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
source: parent_qualified
|
||||
.unwrap_or(file_path)
|
||||
.to_string(),
|
||||
target: path,
|
||||
kind: CodeEdgeKind::Imports,
|
||||
file_path: file_path.to_string(),
|
||||
line_number: Some(node.start_position().row as u32 + 1),
|
||||
});
|
||||
}
|
||||
}
|
||||
"mod_item" => {
|
||||
if let Some(name_node) = node.child_by_field_name("name") {
|
||||
let name = &source[name_node.byte_range()];
|
||||
let qualified = match parent_qualified {
|
||||
Some(p) => format!("{p}::{name}"),
|
||||
None => format!("{file_path}::{name}"),
|
||||
};
|
||||
|
||||
output.nodes.push(CodeNode {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
qualified_name: qualified.clone(),
|
||||
name: name.to_string(),
|
||||
kind: CodeNodeKind::Module,
|
||||
file_path: file_path.to_string(),
|
||||
start_line: node.start_position().row as u32 + 1,
|
||||
end_line: node.end_position().row as u32 + 1,
|
||||
language: "rust".to_string(),
|
||||
community_id: None,
|
||||
is_entry_point: false,
|
||||
graph_index: None,
|
||||
});
|
||||
|
||||
// If it has a body (inline module), walk it
|
||||
if let Some(body) = node.child_by_field_name("body") {
|
||||
self.walk_children(
|
||||
body,
|
||||
source,
|
||||
file_path,
|
||||
repo_id,
|
||||
graph_build_id,
|
||||
Some(&qualified),
|
||||
output,
|
||||
);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
|
||||
// Default: walk children
|
||||
self.walk_children(
|
||||
node,
|
||||
source,
|
||||
file_path,
|
||||
repo_id,
|
||||
graph_build_id,
|
||||
parent_qualified,
|
||||
output,
|
||||
);
|
||||
}
|
||||
|
||||
fn walk_children(
|
||||
&self,
|
||||
node: Node<'_>,
|
||||
source: &str,
|
||||
file_path: &str,
|
||||
repo_id: &str,
|
||||
graph_build_id: &str,
|
||||
parent_qualified: Option<&str>,
|
||||
output: &mut ParseOutput,
|
||||
) {
|
||||
let mut cursor = node.walk();
|
||||
for child in node.children(&mut cursor) {
|
||||
self.walk_tree(
|
||||
child,
|
||||
source,
|
||||
file_path,
|
||||
repo_id,
|
||||
graph_build_id,
|
||||
parent_qualified,
|
||||
output,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
fn extract_calls(
|
||||
&self,
|
||||
node: Node<'_>,
|
||||
source: &str,
|
||||
file_path: &str,
|
||||
repo_id: &str,
|
||||
graph_build_id: &str,
|
||||
caller_qualified: &str,
|
||||
output: &mut ParseOutput,
|
||||
) {
|
||||
if node.kind() == "call_expression" {
|
||||
if let Some(func_node) = node.child_by_field_name("function") {
|
||||
let callee = &source[func_node.byte_range()];
|
||||
output.edges.push(CodeEdge {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
source: caller_qualified.to_string(),
|
||||
target: callee.to_string(),
|
||||
kind: CodeEdgeKind::Calls,
|
||||
file_path: file_path.to_string(),
|
||||
line_number: Some(node.start_position().row as u32 + 1),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
let mut cursor = node.walk();
|
||||
for child in node.children(&mut cursor) {
|
||||
self.extract_calls(
|
||||
child,
|
||||
source,
|
||||
file_path,
|
||||
repo_id,
|
||||
graph_build_id,
|
||||
caller_qualified,
|
||||
output,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
fn has_attribute(&self, node: &Node<'_>, source: &str, attr_name: &str) -> bool {
|
||||
if let Some(prev) = node.prev_sibling() {
|
||||
if prev.kind() == "attribute_item" || prev.kind() == "attribute" {
|
||||
let text = &source[prev.byte_range()];
|
||||
return text.contains(attr_name);
|
||||
}
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
fn has_pub_visibility(&self, node: &Node<'_>, source: &str) -> bool {
|
||||
let mut cursor = node.walk();
|
||||
for child in node.children(&mut cursor) {
|
||||
if child.kind() == "visibility_modifier" {
|
||||
let text = &source[child.byte_range()];
|
||||
return text == "pub";
|
||||
}
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
fn extract_impl_type(&self, node: &Node<'_>, source: &str) -> String {
|
||||
if let Some(type_node) = node.child_by_field_name("type") {
|
||||
return source[type_node.byte_range()].to_string();
|
||||
}
|
||||
"unknown".to_string()
|
||||
}
|
||||
|
||||
fn extract_use_path(&self, use_text: &str) -> Option<String> {
|
||||
// "use foo::bar::baz;" -> "foo::bar::baz"
|
||||
let trimmed = use_text
|
||||
.strip_prefix("use ")?
|
||||
.trim_end_matches(';')
|
||||
.trim();
|
||||
Some(trimmed.to_string())
|
||||
}
|
||||
}
|
||||
|
||||
impl LanguageParser for RustParser {
|
||||
fn language(&self) -> &str {
|
||||
"rust"
|
||||
}
|
||||
|
||||
fn extensions(&self) -> &[&str] {
|
||||
&["rs"]
|
||||
}
|
||||
|
||||
fn parse_file(
|
||||
&self,
|
||||
file_path: &Path,
|
||||
source: &str,
|
||||
repo_id: &str,
|
||||
graph_build_id: &str,
|
||||
) -> Result<ParseOutput, CoreError> {
|
||||
let mut parser = Parser::new();
|
||||
let language = tree_sitter_rust::LANGUAGE;
|
||||
parser
|
||||
.set_language(&language.into())
|
||||
.map_err(|e| CoreError::Graph(format!("Failed to set Rust language: {e}")))?;
|
||||
|
||||
let tree = parser
|
||||
.parse(source, None)
|
||||
.ok_or_else(|| CoreError::Graph("Failed to parse Rust file".to_string()))?;
|
||||
|
||||
let file_path_str = file_path.to_string_lossy().to_string();
|
||||
let mut output = ParseOutput::default();
|
||||
|
||||
// Add file node
|
||||
output.nodes.push(CodeNode {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
qualified_name: file_path_str.clone(),
|
||||
name: file_path
|
||||
.file_name()
|
||||
.map(|n| n.to_string_lossy().to_string())
|
||||
.unwrap_or_default(),
|
||||
kind: CodeNodeKind::File,
|
||||
file_path: file_path_str.clone(),
|
||||
start_line: 1,
|
||||
end_line: source.lines().count() as u32,
|
||||
language: "rust".to_string(),
|
||||
community_id: None,
|
||||
is_entry_point: false,
|
||||
graph_index: None,
|
||||
});
|
||||
|
||||
self.walk_tree(
|
||||
tree.root_node(),
|
||||
source,
|
||||
&file_path_str,
|
||||
repo_id,
|
||||
graph_build_id,
|
||||
None,
|
||||
&mut output,
|
||||
);
|
||||
|
||||
Ok(output)
|
||||
}
|
||||
}
|
||||
419
compliance-graph/src/parsers/typescript.rs
Normal file
419
compliance-graph/src/parsers/typescript.rs
Normal file
@@ -0,0 +1,419 @@
|
||||
use std::path::Path;
|
||||
|
||||
use compliance_core::error::CoreError;
|
||||
use compliance_core::models::graph::{CodeEdge, CodeEdgeKind, CodeNode, CodeNodeKind};
|
||||
use compliance_core::traits::graph_builder::{LanguageParser, ParseOutput};
|
||||
use tree_sitter::{Node, Parser};
|
||||
|
||||
pub struct TypeScriptParser;
|
||||
|
||||
impl TypeScriptParser {
|
||||
pub fn new() -> Self {
|
||||
Self
|
||||
}
|
||||
|
||||
fn walk_tree(
|
||||
&self,
|
||||
node: Node<'_>,
|
||||
source: &str,
|
||||
file_path: &str,
|
||||
repo_id: &str,
|
||||
graph_build_id: &str,
|
||||
parent_qualified: Option<&str>,
|
||||
output: &mut ParseOutput,
|
||||
) {
|
||||
match node.kind() {
|
||||
"function_declaration" => {
|
||||
if let Some(name_node) = node.child_by_field_name("name") {
|
||||
let name = &source[name_node.byte_range()];
|
||||
let qualified = match parent_qualified {
|
||||
Some(p) => format!("{p}.{name}"),
|
||||
None => format!("{file_path}::{name}"),
|
||||
};
|
||||
|
||||
output.nodes.push(CodeNode {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
qualified_name: qualified.clone(),
|
||||
name: name.to_string(),
|
||||
kind: CodeNodeKind::Function,
|
||||
file_path: file_path.to_string(),
|
||||
start_line: node.start_position().row as u32 + 1,
|
||||
end_line: node.end_position().row as u32 + 1,
|
||||
language: "typescript".to_string(),
|
||||
community_id: None,
|
||||
is_entry_point: self.is_exported(&node),
|
||||
graph_index: None,
|
||||
});
|
||||
|
||||
if let Some(body) = node.child_by_field_name("body") {
|
||||
self.extract_calls(
|
||||
body, source, file_path, repo_id, graph_build_id, &qualified, output,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
"class_declaration" => {
|
||||
if let Some(name_node) = node.child_by_field_name("name") {
|
||||
let name = &source[name_node.byte_range()];
|
||||
let qualified = match parent_qualified {
|
||||
Some(p) => format!("{p}.{name}"),
|
||||
None => format!("{file_path}::{name}"),
|
||||
};
|
||||
|
||||
output.nodes.push(CodeNode {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
qualified_name: qualified.clone(),
|
||||
name: name.to_string(),
|
||||
kind: CodeNodeKind::Class,
|
||||
file_path: file_path.to_string(),
|
||||
start_line: node.start_position().row as u32 + 1,
|
||||
end_line: node.end_position().row as u32 + 1,
|
||||
language: "typescript".to_string(),
|
||||
community_id: None,
|
||||
is_entry_point: false,
|
||||
graph_index: None,
|
||||
});
|
||||
|
||||
// Heritage clause (extends/implements)
|
||||
self.extract_heritage(
|
||||
&node, source, file_path, repo_id, graph_build_id, &qualified, output,
|
||||
);
|
||||
|
||||
if let Some(body) = node.child_by_field_name("body") {
|
||||
self.walk_children(
|
||||
body, source, file_path, repo_id, graph_build_id, Some(&qualified),
|
||||
output,
|
||||
);
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
"interface_declaration" => {
|
||||
if let Some(name_node) = node.child_by_field_name("name") {
|
||||
let name = &source[name_node.byte_range()];
|
||||
let qualified = match parent_qualified {
|
||||
Some(p) => format!("{p}.{name}"),
|
||||
None => format!("{file_path}::{name}"),
|
||||
};
|
||||
|
||||
output.nodes.push(CodeNode {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
qualified_name: qualified.clone(),
|
||||
name: name.to_string(),
|
||||
kind: CodeNodeKind::Interface,
|
||||
file_path: file_path.to_string(),
|
||||
start_line: node.start_position().row as u32 + 1,
|
||||
end_line: node.end_position().row as u32 + 1,
|
||||
language: "typescript".to_string(),
|
||||
community_id: None,
|
||||
is_entry_point: false,
|
||||
graph_index: None,
|
||||
});
|
||||
}
|
||||
}
|
||||
"method_definition" | "public_field_definition" => {
|
||||
if let Some(name_node) = node.child_by_field_name("name") {
|
||||
let name = &source[name_node.byte_range()];
|
||||
let qualified = match parent_qualified {
|
||||
Some(p) => format!("{p}.{name}"),
|
||||
None => format!("{file_path}::{name}"),
|
||||
};
|
||||
|
||||
output.nodes.push(CodeNode {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
qualified_name: qualified.clone(),
|
||||
name: name.to_string(),
|
||||
kind: CodeNodeKind::Method,
|
||||
file_path: file_path.to_string(),
|
||||
start_line: node.start_position().row as u32 + 1,
|
||||
end_line: node.end_position().row as u32 + 1,
|
||||
language: "typescript".to_string(),
|
||||
community_id: None,
|
||||
is_entry_point: false,
|
||||
graph_index: None,
|
||||
});
|
||||
|
||||
if let Some(body) = node.child_by_field_name("body") {
|
||||
self.extract_calls(
|
||||
body, source, file_path, repo_id, graph_build_id, &qualified, output,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
"lexical_declaration" | "variable_declaration" => {
|
||||
self.extract_arrow_functions(
|
||||
node, source, file_path, repo_id, graph_build_id, parent_qualified, output,
|
||||
);
|
||||
}
|
||||
"import_statement" => {
|
||||
let text = &source[node.byte_range()];
|
||||
if let Some(module) = self.extract_import_source(text) {
|
||||
output.edges.push(CodeEdge {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
source: parent_qualified.unwrap_or(file_path).to_string(),
|
||||
target: module,
|
||||
kind: CodeEdgeKind::Imports,
|
||||
file_path: file_path.to_string(),
|
||||
line_number: Some(node.start_position().row as u32 + 1),
|
||||
});
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
|
||||
self.walk_children(
|
||||
node, source, file_path, repo_id, graph_build_id, parent_qualified, output,
|
||||
);
|
||||
}
|
||||
|
||||
fn walk_children(
|
||||
&self,
|
||||
node: Node<'_>,
|
||||
source: &str,
|
||||
file_path: &str,
|
||||
repo_id: &str,
|
||||
graph_build_id: &str,
|
||||
parent_qualified: Option<&str>,
|
||||
output: &mut ParseOutput,
|
||||
) {
|
||||
let mut cursor = node.walk();
|
||||
for child in node.children(&mut cursor) {
|
||||
self.walk_tree(
|
||||
child, source, file_path, repo_id, graph_build_id, parent_qualified, output,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
fn extract_calls(
|
||||
&self,
|
||||
node: Node<'_>,
|
||||
source: &str,
|
||||
file_path: &str,
|
||||
repo_id: &str,
|
||||
graph_build_id: &str,
|
||||
caller_qualified: &str,
|
||||
output: &mut ParseOutput,
|
||||
) {
|
||||
if node.kind() == "call_expression" {
|
||||
if let Some(func_node) = node.child_by_field_name("function") {
|
||||
let callee = &source[func_node.byte_range()];
|
||||
output.edges.push(CodeEdge {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
source: caller_qualified.to_string(),
|
||||
target: callee.to_string(),
|
||||
kind: CodeEdgeKind::Calls,
|
||||
file_path: file_path.to_string(),
|
||||
line_number: Some(node.start_position().row as u32 + 1),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
let mut cursor = node.walk();
|
||||
for child in node.children(&mut cursor) {
|
||||
self.extract_calls(
|
||||
child, source, file_path, repo_id, graph_build_id, caller_qualified, output,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
fn extract_arrow_functions(
|
||||
&self,
|
||||
node: Node<'_>,
|
||||
source: &str,
|
||||
file_path: &str,
|
||||
repo_id: &str,
|
||||
graph_build_id: &str,
|
||||
parent_qualified: Option<&str>,
|
||||
output: &mut ParseOutput,
|
||||
) {
|
||||
let mut cursor = node.walk();
|
||||
for child in node.children(&mut cursor) {
|
||||
if child.kind() == "variable_declarator" {
|
||||
let name_node = child.child_by_field_name("name");
|
||||
let value_node = child.child_by_field_name("value");
|
||||
if let (Some(name_n), Some(value_n)) = (name_node, value_node) {
|
||||
if value_n.kind() == "arrow_function" || value_n.kind() == "function" {
|
||||
let name = &source[name_n.byte_range()];
|
||||
let qualified = match parent_qualified {
|
||||
Some(p) => format!("{p}.{name}"),
|
||||
None => format!("{file_path}::{name}"),
|
||||
};
|
||||
|
||||
output.nodes.push(CodeNode {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
qualified_name: qualified.clone(),
|
||||
name: name.to_string(),
|
||||
kind: CodeNodeKind::Function,
|
||||
file_path: file_path.to_string(),
|
||||
start_line: child.start_position().row as u32 + 1,
|
||||
end_line: child.end_position().row as u32 + 1,
|
||||
language: "typescript".to_string(),
|
||||
community_id: None,
|
||||
is_entry_point: false,
|
||||
graph_index: None,
|
||||
});
|
||||
|
||||
if let Some(body) = value_n.child_by_field_name("body") {
|
||||
self.extract_calls(
|
||||
body, source, file_path, repo_id, graph_build_id, &qualified,
|
||||
output,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn extract_heritage(
|
||||
&self,
|
||||
node: &Node<'_>,
|
||||
source: &str,
|
||||
file_path: &str,
|
||||
repo_id: &str,
|
||||
graph_build_id: &str,
|
||||
class_qualified: &str,
|
||||
output: &mut ParseOutput,
|
||||
) {
|
||||
let mut cursor = node.walk();
|
||||
for child in node.children(&mut cursor) {
|
||||
if child.kind() == "class_heritage" {
|
||||
let text = &source[child.byte_range()];
|
||||
// "extends Base implements IFoo, IBar"
|
||||
if let Some(rest) = text.strip_prefix("extends ") {
|
||||
let base = rest.split_whitespace().next().unwrap_or(rest);
|
||||
output.edges.push(CodeEdge {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
source: class_qualified.to_string(),
|
||||
target: base.trim_matches(',').to_string(),
|
||||
kind: CodeEdgeKind::Inherits,
|
||||
file_path: file_path.to_string(),
|
||||
line_number: Some(child.start_position().row as u32 + 1),
|
||||
});
|
||||
}
|
||||
if text.contains("implements ") {
|
||||
if let Some(impl_part) = text.split("implements ").nth(1) {
|
||||
for iface in impl_part.split(',') {
|
||||
let iface = iface.trim();
|
||||
if !iface.is_empty() {
|
||||
output.edges.push(CodeEdge {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
source: class_qualified.to_string(),
|
||||
target: iface.to_string(),
|
||||
kind: CodeEdgeKind::Implements,
|
||||
file_path: file_path.to_string(),
|
||||
line_number: Some(child.start_position().row as u32 + 1),
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn is_exported(&self, node: &Node<'_>) -> bool {
|
||||
if let Some(parent) = node.parent() {
|
||||
return parent.kind() == "export_statement";
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
fn extract_import_source(&self, import_text: &str) -> Option<String> {
|
||||
let from_idx = import_text.find("from ");
|
||||
let start = if let Some(idx) = from_idx {
|
||||
idx + 5
|
||||
} else {
|
||||
import_text.find("import ")? + 7
|
||||
};
|
||||
let rest = &import_text[start..];
|
||||
let module = rest
|
||||
.trim()
|
||||
.trim_matches(|c| c == '\'' || c == '"' || c == ';' || c == ' ');
|
||||
if module.is_empty() {
|
||||
None
|
||||
} else {
|
||||
Some(module.to_string())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl LanguageParser for TypeScriptParser {
|
||||
fn language(&self) -> &str {
|
||||
"typescript"
|
||||
}
|
||||
|
||||
fn extensions(&self) -> &[&str] {
|
||||
&["ts", "tsx"]
|
||||
}
|
||||
|
||||
fn parse_file(
|
||||
&self,
|
||||
file_path: &Path,
|
||||
source: &str,
|
||||
repo_id: &str,
|
||||
graph_build_id: &str,
|
||||
) -> Result<ParseOutput, CoreError> {
|
||||
let mut parser = Parser::new();
|
||||
let language = tree_sitter_typescript::LANGUAGE_TYPESCRIPT;
|
||||
parser
|
||||
.set_language(&language.into())
|
||||
.map_err(|e| CoreError::Graph(format!("Failed to set TypeScript language: {e}")))?;
|
||||
|
||||
let tree = parser
|
||||
.parse(source, None)
|
||||
.ok_or_else(|| CoreError::Graph("Failed to parse TypeScript file".to_string()))?;
|
||||
|
||||
let file_path_str = file_path.to_string_lossy().to_string();
|
||||
let mut output = ParseOutput::default();
|
||||
|
||||
output.nodes.push(CodeNode {
|
||||
id: None,
|
||||
repo_id: repo_id.to_string(),
|
||||
graph_build_id: graph_build_id.to_string(),
|
||||
qualified_name: file_path_str.clone(),
|
||||
name: file_path
|
||||
.file_name()
|
||||
.map(|n| n.to_string_lossy().to_string())
|
||||
.unwrap_or_default(),
|
||||
kind: CodeNodeKind::File,
|
||||
file_path: file_path_str.clone(),
|
||||
start_line: 1,
|
||||
end_line: source.lines().count() as u32,
|
||||
language: "typescript".to_string(),
|
||||
community_id: None,
|
||||
is_entry_point: false,
|
||||
graph_index: None,
|
||||
});
|
||||
|
||||
self.walk_tree(
|
||||
tree.root_node(),
|
||||
source,
|
||||
&file_path_str,
|
||||
repo_id,
|
||||
graph_build_id,
|
||||
None,
|
||||
&mut output,
|
||||
);
|
||||
|
||||
Ok(output)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user