rubydex 0.1.0.beta11 → 0.1.0.beta13

data/rust/rubydex/tests/cli.rs

@@ -1,167 +1,185 @@
-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"));
-    });
-}
+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 1 files"));
+
+    rdx(&["."])
+        .success()
+        .stderr(predicate::str::is_empty())
+        .stdout(predicate::str::contains("Indexed 1 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 4 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 3 files"))
+            .stdout(predicate::str::contains("Found 7 names"))
+            .stdout(predicate::str::contains("Found 7 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:BasicObject" [label="BasicObject",shape=hexagon];
+                "Name:BasicObject" -> "def_<ID>" [dir=both];
+                "Name:Class" [label="Class",shape=hexagon];
+                "Name:Class" -> "def_<ID>" [dir=both];
+                "Name:Kernel" [label="Kernel",shape=hexagon];
+                "Name:Kernel" -> "def_<ID>" [dir=both];
+                "Name:Module" [label="Module",shape=hexagon];
+                "Name:Module" -> "def_<ID>" [dir=both];
+                "Name:Object" [label="Object",shape=hexagon];
+                "Name:Object" -> "def_<ID>" [dir=both];
+                "Name:SimpleClass" [label="SimpleClass",shape=hexagon];
+                "Name:SimpleClass" -> "def_<ID>" [dir=both];
+
+                "def_<ID>" [label="Class(BasicObject)",shape=ellipse];
+                "def_<ID>" [label="Class(Class)",shape=ellipse];
+                "def_<ID>" [label="Class(Module)",shape=ellipse];
+                "def_<ID>" [label="Class(Object)",shape=ellipse];
+                "def_<ID>" [label="Class(SimpleClass)",shape=ellipse];
+                "def_<ID>" [label="Module(Kernel)",shape=ellipse];
+
+                "file://<PATH>/simple.rb" [label="simple.rb",shape=box];
+                "def_<ID>" -> "file://<PATH>/simple.rb";
+                "rubydex:built-in" [label="rubydex:built-in",shape=box];
+                "def_<ID>" -> "rubydex:built-in";
+                "def_<ID>" -> "rubydex:built-in";
+                "def_<ID>" -> "rubydex:built-in";
+                "def_<ID>" -> "rubydex:built-in";
+                "def_<ID>" -> "rubydex:built-in";
+
+            }
+
+            "#
+        });
+
+        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-mcp/Cargo.toml

@@ -1,28 +1,28 @@
-[package]
-name = "rubydex-mcp"
-version = "0.1.0"
-edition = "2024"
-rust-version = "1.89.0"
-license = "MIT"
-
-[[bin]]
-name = "rubydex_mcp"
-path = "src/main.rs"
-
-[dependencies]
-rubydex = { path = "../rubydex" }
-clap = { version = "4.5.16", features = ["derive"] }
-rmcp = { version = "0.15", features = ["server", "macros", "transport-io", "schemars"] }
-tokio = { version = "1", features = ["macros", "rt", "io-std"] }
-serde = { version = "1", features = ["derive"] }
-serde_json = "1"
-schemars = "1"
-url = "2"
-
-[dev-dependencies]
-rubydex = { path = "../rubydex", features = ["test_utils"] }
-assert_cmd = "2.0"
-serde_json = "1"
-
-[lints]
-workspace = true
+[package]
+name = "rubydex-mcp"
+version = "0.1.0"
+edition = "2024"
+rust-version = "1.89.0"
+license = "MIT"
+
+[[bin]]
+name = "rubydex_mcp"
+path = "src/main.rs"
+
+[dependencies]
+rubydex = { path = "../rubydex" }
+clap = { version = "4.5.16", features = ["derive"] }
+rmcp = { version = "0.15", features = ["server", "macros", "transport-io", "schemars"] }
+tokio = { version = "1", features = ["macros", "rt", "io-std"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+schemars = "1"
+url = "2"
+
+[dev-dependencies]
+rubydex = { path = "../rubydex", features = ["test_utils"] }
+assert_cmd = "2.0"
+serde_json = "1"
+
+[lints]
+workspace = true

data/rust/rubydex-mcp/src/main.rs

@@ -1,48 +1,48 @@
-use clap::Parser;
-
-mod server;
-mod tools;
-
-#[derive(Parser, Debug)]
-#[command(
-    name = "rubydex_mcp",
-    about = "Rubydex MCP server for AI-assisted Ruby code intelligence",
-    version
-)]
-struct Args {
-    #[arg(value_name = "PATH", default_value = ".")]
-    path: String,
-}
-
-fn main() {
-    let args = Args::parse();
-
-    let root = match std::fs::canonicalize(&args.path) {
-        Ok(p) => p
-            .into_os_string()
-            .into_string()
-            .expect("Project path is not valid UTF-8"),
-        Err(e) => {
-            eprintln!("Warning: failed to canonicalize '{}': {e}", args.path);
-            args.path
-        }
-    };
-
-    // Create the server and start indexing in the background.
-    let server = server::RubydexServer::new(root.clone());
-    server.spawn_indexer(root);
-
-    // Serve MCP over stdio immediately while indexing runs.
-    // We need to do this because Claude Code's default MCP server timeout is 30 seconds,
-    // And in big codebases it's possible to exceed that and Claude Code would just consider
-    // the server fail to connect.
-    let rt = tokio::runtime::Builder::new_current_thread()
-        .enable_all()
-        .build()
-        .expect("Failed to build tokio runtime");
-
-    if let Err(e) = rt.block_on(server.serve()) {
-        eprintln!("MCP server error: {e}");
-        std::process::exit(1);
-    }
-}
+use clap::Parser;
+
+mod server;
+mod tools;
+
+#[derive(Parser, Debug)]
+#[command(
+    name = "rubydex_mcp",
+    about = "Rubydex MCP server for AI-assisted Ruby code intelligence",
+    version
+)]
+struct Args {
+    #[arg(value_name = "PATH", default_value = ".")]
+    path: String,
+}
+
+fn main() {
+    let args = Args::parse();
+
+    let root = match std::fs::canonicalize(&args.path) {
+        Ok(p) => p
+            .into_os_string()
+            .into_string()
+            .expect("Project path is not valid UTF-8"),
+        Err(e) => {
+            eprintln!("Warning: failed to canonicalize '{}': {e}", args.path);
+            args.path
+        }
+    };
+
+    // Create the server and start indexing in the background.
+    let server = server::RubydexServer::new(root.clone());
+    server.spawn_indexer(root);
+
+    // Serve MCP over stdio immediately while indexing runs.
+    // We need to do this because Claude Code's default MCP server timeout is 30 seconds,
+    // And in big codebases it's possible to exceed that and Claude Code would just consider
+    // the server fail to connect.
+    let rt = tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .expect("Failed to build tokio runtime");
+
+    if let Err(e) = rt.block_on(server.serve()) {
+        eprintln!("MCP server error: {e}");
+        std::process::exit(1);
+    }
+}