rubydex 0.1.0.beta1-x86_64-linux → 0.1.0.beta2-x86_64-linux

data/rust/rubydex/src/test_utils/local_graph_test.rs

@@ -0,0 +1,166 @@
+use super::normalize_indentation;
+use crate::indexing::local_graph::LocalGraph;
+use crate::indexing::ruby_indexer::RubyIndexer;
+use crate::model::definitions::Definition;
+use crate::model::ids::UriId;
+use crate::offset::Offset;
+use crate::position::Position;
+
+#[cfg(any(test, feature = "test_utils"))]
+pub struct LocalGraphTest {
+    uri: String,
+    graph: LocalGraph,
+}
+
+#[cfg(any(test, feature = "test_utils"))]
+impl LocalGraphTest {
+    #[must_use]
+    pub fn new(uri: &str, source: &str) -> Self {
+        let uri = uri.to_string();
+        let source = normalize_indentation(source);
+
+        let mut indexer = RubyIndexer::new(uri.clone(), &source);
+        indexer.index();
+        let graph = indexer.local_graph();
+
+        Self { uri, graph }
+    }
+
+    #[must_use]
+    pub fn uri(&self) -> &str {
+        &self.uri
+    }
+
+    #[must_use]
+    pub fn graph(&self) -> &LocalGraph {
+        &self.graph
+    }
+
+    /// # Panics
+    ///
+    /// Panics if a definition cannot be found at the given location.
+    #[must_use]
+    pub fn all_definitions_at<'a>(&'a self, location: &str) -> Vec<&'a Definition> {
+        let (uri, offset) = self.parse_location(&format!("{}:{}", self.uri(), location));
+        let uri_id = UriId::from(&uri);
+
+        let definitions = self
+            .graph()
+            .definitions()
+            .values()
+            .filter(|def| def.uri_id() == &uri_id && def.offset() == &offset)
+            .collect::<Vec<_>>();
+
+        assert!(
+            !definitions.is_empty(),
+            "could not find a definition matching {location}, did you mean one of the following: {:?}",
+            {
+                let mut offsets = self
+                    .graph()
+                    .definitions()
+                    .values()
+                    .map(crate::model::definitions::Definition::offset)
+                    .collect::<Vec<_>>();
+
+                offsets.sort_by_key(|a| a.start());
+
+                offsets
+                    .iter()
+                    .map(|offset| offset.to_display_range(self.graph.document()))
+                    .collect::<Vec<_>>()
+            }
+        );
+
+        definitions
+    }
+
+    /// # Panics
+    ///
+    /// Panics if no definition or multiple definitions are found at the given location.
+    #[must_use]
+    pub fn definition_at<'a>(&'a self, location: &str) -> &'a Definition {
+        let definitions = self.all_definitions_at(location);
+        assert!(
+            definitions.len() < 2,
+            "found more than one definition matching {location}"
+        );
+
+        definitions[0]
+    }
+
+    /// Parses a location string like `<file:///foo.rb:3:0-3:5>` into `(uri, start_offset, end_offset)`
+    ///
+    /// Format: uri:start_line:start_column-end_line:end_column
+    /// Line and column numbers are 0-indexed
+    ///
+    /// # Panics
+    ///
+    /// Panics if the location format is invalid, the URI has no source, or the positions are invalid.
+    #[must_use]
+    pub fn parse_location(&self, location: &str) -> (String, Offset) {
+        let (uri, start_position, end_position) = Self::parse_location_positions(location);
+        let line_index = self.graph.document().line_index();
+
+        let start_offset = line_index.offset(start_position).unwrap_or(0.into());
+        let end_offset = line_index.offset(end_position).unwrap_or(0.into());
+
+        (uri, Offset::new(start_offset.into(), end_offset.into()))
+    }
+
+    fn parse_location_positions(location: &str) -> (String, Position, Position) {
+        let trimmed = location.trim().trim_start_matches('<').trim_end_matches('>');
+
+        let (start_part, end_part) = trimmed.rsplit_once('-').unwrap_or_else(|| {
+            panic!("Invalid location format: {location} (expected uri:start_line:start_column-end_line:end_column)")
+        });
+
+        let (start_prefix, start_column_str) = start_part
+            .rsplit_once(':')
+            .unwrap_or_else(|| panic!("Invalid location format: missing start column in {location}"));
+        let (uri, start_line_str) = start_prefix
+            .rsplit_once(':')
+            .unwrap_or_else(|| panic!("Invalid location format: missing start line in {location}"));
+
+        let (end_line_str, end_column_str) = end_part
+            .split_once(':')
+            .unwrap_or_else(|| panic!("Invalid location format: missing end line or column in {location}"));
+
+        let start_line = Self::parse_number(start_line_str, "start line", location);
+        let start_column = Self::parse_number(start_column_str, "start column", location);
+        let end_line = Self::parse_number(end_line_str, "end line", location);
+        let end_column = Self::parse_number(end_column_str, "end column", location);
+
+        (
+            uri.to_string(),
+            Position {
+                line: start_line - 1,
+                col: start_column - 1,
+            },
+            Position {
+                line: end_line - 1,
+                col: end_column - 1,
+            },
+        )
+    }
+
+    fn parse_number(value: &str, field: &str, location: &str) -> u32 {
+        value
+            .parse()
+            .unwrap_or_else(|_| panic!("Invalid {field} '{value}' in location {location}"))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_locations() {
+        let context = LocalGraphTest::new("file://foo.rb", "class Foo; end");
+
+        let (uri, offset) = context.parse_location("file://foo.rb:1:1-1:14");
+
+        assert_eq!(uri, "file://foo.rb");
+        assert_eq!(offset, Offset::new(0, 13));
+    }
+}

data/rust/rubydex/src/test_utils.rs

@@ -0,0 +1,52 @@
+mod context;
+mod graph_test;
+mod local_graph_test;
+
+pub use context::Context;
+pub use context::with_context;
+pub use graph_test::GraphTest;
+pub use local_graph_test::LocalGraphTest;
+
+#[must_use]
+pub fn normalize_indentation(input: &str) -> String {
+    let input = if let Some(rest) = input.strip_prefix('\n') {
+        match rest.chars().next() {
+            Some(' ' | '\t') => rest,
+            _ => input,
+        }
+    } else {
+        input
+    };
+
+    let lines: Vec<&str> = input.lines().collect();
+    if lines.is_empty() {
+        return String::new();
+    }
+
+    let first_non_empty_line = match lines.iter().find(|line| !line.trim().is_empty()) {
+        Some(line) => *line,
+        None => return input.to_string(),
+    };
+
+    let base_indent = first_non_empty_line.len() - first_non_empty_line.trim_start().len();
+
+    let mut normalized = lines
+        .iter()
+        .map(|line| {
+            if line.trim().is_empty() {
+                ""
+            } else if line.len() >= base_indent && line.chars().take(base_indent).all(char::is_whitespace) {
+                &line[base_indent..]
+            } else {
+                line
+            }
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+
+    if input.ends_with('\n') {
+        normalized.push('\n');
+    }
+
+    normalized
+}

data/rust/rubydex/src/visualization/dot.rs

@@ -0,0 +1,176 @@
+//! DOT format generator for Graphviz visualization of the graph structure.
+
+use std::fmt::Write;
+
+use crate::model::graph::Graph;
+
+const NAME_NODE_SHAPE: &str = "hexagon";
+const DEFINITION_NODE_SHAPE: &str = "ellipse";
+const URI_NODE_SHAPE: &str = "box";
+
+/// Escapes a string for use in DOT format labels and identifiers.
+fn escape_dot_string(s: &str) -> String {
+    if !s.contains('"') {
+        return s.to_string();
+    }
+
+    let mut result = String::with_capacity(s.len());
+    for c in s.chars() {
+        match c {
+            '"' => result.push_str("\\\""),
+            _ => result.push(c),
+        }
+    }
+    result
+}
+
+#[must_use]
+pub fn generate(graph: &Graph) -> String {
+    let mut output = String::new();
+    output.push_str("digraph {\n");
+    output.push_str("    rankdir=TB;\n\n");
+
+    write_declaration_nodes(&mut output, graph);
+    write_definition_nodes(&mut output, graph);
+    write_document_nodes(&mut output, graph);
+
+    output.push_str("}\n");
+    output
+}
+
+fn write_declaration_nodes(output: &mut String, graph: &Graph) {
+    let mut declarations: Vec<_> = graph.declarations().values().collect();
+    declarations.sort_by(|a, b| a.name().cmp(b.name()));
+
+    for declaration in declarations {
+        let name = declaration.name();
+        let escaped_name = escape_dot_string(name);
+        let node_id = format!("Name:{name}");
+        let _ = writeln!(
+            output,
+            "    \"{node_id}\" [label=\"{escaped_name}\",shape={NAME_NODE_SHAPE}];"
+        );
+
+        for def_id in declaration.definitions() {
+            let _ = writeln!(output, "    \"{node_id}\" -> \"def_{def_id}\" [dir=both];");
+        }
+    }
+
+    output.push('\n');
+}
+
+fn write_definition_nodes(output: &mut String, graph: &Graph) {
+    let mut definitions: Vec<_> = graph
+        .definitions()
+        .iter()
+        .filter_map(|(def_id, definition)| {
+            graph
+                .declarations()
+                .get(graph.definitions_to_declarations().get(def_id).unwrap())
+                .map(|declaration| {
+                    let def_type = definition.kind();
+                    let escaped_name = escape_dot_string(declaration.name());
+                    let label = format!("{def_type}({escaped_name})");
+                    let line = format!("    \"def_{def_id}\" [label=\"{label}\",shape={DEFINITION_NODE_SHAPE}];\n");
+                    (label, line)
+                })
+        })
+        .collect();
+
+    definitions.sort_by(|a, b| a.0.cmp(&b.0));
+
+    for (_, line) in definitions {
+        output.push_str(&line);
+    }
+    output.push('\n');
+}
+
+fn write_document_nodes(output: &mut String, graph: &Graph) {
+    let mut documents: Vec<_> = graph.documents().values().collect();
+    documents.sort_by(|a, b| a.uri().cmp(b.uri()));
+
+    for document in documents {
+        let uri = document.uri();
+        let label = uri.rsplit('/').next().unwrap_or(uri);
+        let escaped_uri = escape_dot_string(uri);
+        let escaped_label = escape_dot_string(label);
+        let _ = writeln!(
+            output,
+            "    \"{escaped_uri}\" [label=\"{escaped_label}\",shape={URI_NODE_SHAPE}];"
+        );
+
+        for def_id in document.definitions() {
+            let _ = writeln!(output, "    \"def_{def_id}\" -> \"{escaped_uri}\";");
+        }
+    }
+    output.push('\n');
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::GraphTest;
+
+    fn create_test_graph() -> GraphTest {
+        let mut graph_test = GraphTest::new();
+        graph_test.index_uri(
+            "file:///test.rb",
+            "
+                class TestClass
+                end
+
+                module TestModule
+                end
+            ",
+        );
+        graph_test.resolve();
+        graph_test
+    }
+
+    #[test]
+    fn test_dot_generation() {
+        let context = create_test_graph();
+        let dot_output = generate(context.graph());
+
+        let class_def_id = context
+            .graph()
+            .definitions()
+            .iter()
+            .find(|(_, def)| matches!(def, crate::model::definitions::Definition::Class(_)))
+            .map(|(id, _)| id.to_string())
+            .unwrap();
+
+        let module_def_id = context
+            .graph()
+            .definitions()
+            .iter()
+            .find(|(_, def)| matches!(def, crate::model::definitions::Definition::Module(_)))
+            .map(|(id, _)| id.to_string())
+            .unwrap();
+
+        let expected = format!(
+            r#"digraph {{
+    rankdir=TB;
+
+    "Name:Class" [label="Class",shape=hexagon];
+    "Name:Module" [label="Module",shape=hexagon];
+    "Name:Object" [label="Object",shape=hexagon];
+    "Name:TestClass" [label="TestClass",shape=hexagon];
+    "Name:TestClass" -> "def_{class_def_id}" [dir=both];
+    "Name:TestModule" [label="TestModule",shape=hexagon];
+    "Name:TestModule" -> "def_{module_def_id}" [dir=both];
+
+    "def_{class_def_id}" [label="Class(TestClass)",shape=ellipse];
+    "def_{module_def_id}" [label="Module(TestModule)",shape=ellipse];
+
+    "file:///test.rb" [label="test.rb",shape=box];
+    "def_{class_def_id}" -> "file:///test.rb";
+    "def_{module_def_id}" -> "file:///test.rb";
+
+}}
+"#
+        );
+
+        assert_eq!(dot_output, expected);
+    }
+}

data/rust/rubydex/src/visualization.rs

@@ -0,0 +1,6 @@
+//! Graph visualization module for the Index structure.
+//!
+//! This module provides functionality to generate visual representations of the Index's
+//! internal graph structure, showing the relationships between Names, Definitions, and URIs.
+
+pub mod dot;

data/rust/rubydex/tests/cli.rs

@@ -0,0 +1,167 @@
+use assert_cmd::{assert::Assert, prelude::*};
+use predicates::prelude::*;
+use regex::Regex;
+use rubydex::test_utils::{normalize_indentation, with_context};
+use std::process::Command;
+
+fn rdx_cmd(args: &[&str]) -> Command {
+    let mut cmd = Command::cargo_bin("rubydex_cli").unwrap();
+    cmd.args(args);
+    cmd
+}
+
+fn rdx(args: &[&str]) -> Assert {
+    rdx_cmd(args).assert()
+}
+
+#[test]
+fn prints_help() {
+    rdx(&["--help"])
+        .success()
+        .stdout(predicate::str::contains("A Static Analysis Toolkit for Ruby"))
+        .stdout(predicate::str::contains("Usage:"))
+        .stdout(predicate::str::contains("--stats"))
+        .stdout(predicate::str::contains("--visualize"))
+        .stdout(predicate::str::contains("--stop-after"));
+}
+
+#[test]
+fn paths_argument_variants() {
+    rdx(&[])
+        .success()
+        .stderr(predicate::str::is_empty())
+        .stdout(predicate::str::contains("Indexed 0 files"));
+
+    rdx(&["."])
+        .success()
+        .stderr(predicate::str::is_empty())
+        .stdout(predicate::str::contains("Indexed 0 files"));
+
+    with_context(|context| {
+        context.write("dir1/file1.rb", "class Class1\nend\n");
+        context.write("dir1/file2.rb", "class Class2\nend\n");
+        context.write("dir2/file1.rb", "class Class3\nend\n");
+        context.write("dir2/file2.rb", "class Class4\nend\n"); // not indexed
+
+        rdx(&[
+            context.absolute_path_to("dir1").to_str().unwrap(),
+            context.absolute_path_to("dir2/file1.rb").to_str().unwrap(),
+        ])
+        .success()
+        .stderr(predicate::str::is_empty())
+        .stdout(predicate::str::contains("Indexed 3 files"));
+    });
+}
+
+#[test]
+fn prints_index_metrics() {
+    with_context(|context| {
+        context.write("file1.rb", "class FirstClass\nend\n");
+        context.write("file2.rb", "module SecondModule\nend\n");
+
+        rdx(&[context.absolute_path().to_str().unwrap()])
+            .success()
+            .stderr(predicate::str::is_empty())
+            .stdout(predicate::str::contains("Indexed 2 files"))
+            .stdout(predicate::str::contains("Found 5 names"))
+            .stdout(predicate::str::contains("Found 2 definitions"));
+    });
+}
+
+fn normalize_visualization_output(output: &str) -> String {
+    let def_re = Regex::new(r"def_-?[a-f0-9]+").unwrap();
+    let uri_re = Regex::new(r#"file://[^"]+/([^/"]+\.rb)"#).unwrap();
+
+    let normalized = def_re.replace_all(output, "def_<ID>");
+    uri_re.replace_all(&normalized, "file://<PATH>/$1").to_string()
+}
+
+#[test]
+fn visualize_simple_class() {
+    with_context(|context| {
+        context.write("simple.rb", "class SimpleClass\nend\n");
+
+        let output = rdx_cmd(&[context.absolute_path().to_str().unwrap(), "--visualize"])
+            .output()
+            .unwrap();
+
+        assert!(output.status.success());
+
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        let normalized = normalize_visualization_output(&stdout);
+
+        let expected = normalize_indentation({
+            r#"
+            digraph {
+                rankdir=TB;
+
+                "Name:Class" [label="Class",shape=hexagon];
+                "Name:Module" [label="Module",shape=hexagon];
+                "Name:Object" [label="Object",shape=hexagon];
+                "Name:SimpleClass" [label="SimpleClass",shape=hexagon];
+                "Name:SimpleClass" -> "def_<ID>" [dir=both];
+
+                "def_<ID>" [label="Class(SimpleClass)",shape=ellipse];
+
+                "file://<PATH>/simple.rb" [label="simple.rb",shape=box];
+                "def_<ID>" -> "file://<PATH>/simple.rb";
+
+            }
+
+            "#
+        });
+
+        assert_eq!(normalized, expected);
+    });
+}
+
+#[test]
+fn stop_after() {
+    with_context(|context| {
+        context.write("file1.rb", "class Class1\nend\n");
+        context.write("file2.rb", "class Class2\nend\n");
+
+        rdx(&[
+            context.absolute_path().to_str().unwrap(),
+            "--stop-after",
+            "listing",
+            "--stats",
+        ])
+        .success()
+        .stdout(predicate::str::contains("Listing"))
+        .stdout(predicate::str::contains("Indexing").not())
+        .stdout(predicate::str::contains("Resolution").not())
+        .stdout(predicate::str::contains("Querying").not());
+
+        rdx(&[
+            context.absolute_path().to_str().unwrap(),
+            "--stop-after",
+            "indexing",
+            "--stats",
+        ])
+        .success()
+        .stdout(predicate::str::contains("Listing"))
+        .stdout(predicate::str::contains("Indexing"))
+        .stdout(predicate::str::contains("Resolution").not())
+        .stdout(predicate::str::contains("Querying").not());
+
+        rdx(&[
+            context.absolute_path().to_str().unwrap(),
+            "--stop-after",
+            "resolution",
+            "--stats",
+        ])
+        .success()
+        .stdout(predicate::str::contains("Listing"))
+        .stdout(predicate::str::contains("Indexing"))
+        .stdout(predicate::str::contains("Resolution"))
+        .stdout(predicate::str::contains("Querying").not());
+
+        rdx(&[context.absolute_path().to_str().unwrap(), "--stats"])
+            .success()
+            .stdout(predicate::str::contains("Listing"))
+            .stdout(predicate::str::contains("Indexing"))
+            .stdout(predicate::str::contains("Resolution"))
+            .stdout(predicate::str::contains("Querying"));
+    });
+}

data/rust/rubydex-sys/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "rubydex-sys"
+version = "0.1.0"
+edition = "2024"
+license = "MIT"
+
+[lib]
+crate-type = ["cdylib", "staticlib"]
+
+[dependencies]
+rubydex = { path = "../rubydex" }
+libc = "0.2.174"
+url = "2.5.4"
+line-index = "0.1.2"
+
+[build-dependencies]
+cbindgen = "0.29"
+
+[lints]
+workspace = true

data/rust/rubydex-sys/build.rs

@@ -0,0 +1,14 @@
+extern crate cbindgen;
+
+fn main() {
+    cbindgen::generate(".")
+        .expect("Unable to generate bindings")
+        .write_to_file("rustbindings.h");
+
+    // Set the install name for macOS dylibs so they can be found via @rpath at runtime.
+    // This works for both native and cross-compilation scenarios.
+    let target = std::env::var("TARGET").unwrap_or_default();
+    if target.contains("apple") {
+        println!("cargo::rustc-cdylib-link-arg=-Wl,-install_name,@rpath/librubydex_sys.dylib");
+    }
+}

data/rust/rubydex-sys/cbindgen.toml

@@ -0,0 +1,12 @@
+language = "C"
+
+include_guard = "RUSTBINDINGS_H"
+
+autogen_warning = "/* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */"
+
+tab_width = 4
+
+usize_is_size_t = true
+
+[enum]
+prefix_with_name = true