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

data/rust/rubydex/src/stats/memory.rs

@@ -0,0 +1,71 @@
+use std::io;
+
+#[cfg(unix)]
+use libc::{RUSAGE_SELF, getrusage, rusage};
+
+/// Memory statistics for the current process
+#[derive(Debug, Clone, Copy)]
+pub struct MemoryStats {
+    /// Maximum resident set size in bytes
+    pub max_rss_bytes: i64,
+}
+
+impl MemoryStats {
+    /// Get current memory statistics using getrusage
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the `getrusage` system call fails.
+    #[cfg(unix)]
+    pub fn current() -> Result<Self, io::Error> {
+        unsafe {
+            let mut usage = std::mem::MaybeUninit::<rusage>::uninit();
+            let result = getrusage(RUSAGE_SELF, usage.as_mut_ptr());
+
+            if result == 0 {
+                let usage = usage.assume_init();
+                // On macOS and BSD, ru_maxrss is in bytes
+                // On Linux, ru_maxrss is in kilobytes
+                let max_rss_bytes = if cfg!(target_os = "linux") {
+                    usage.ru_maxrss * 1024
+                } else {
+                    usage.ru_maxrss
+                };
+
+                Ok(Self { max_rss_bytes })
+            } else {
+                Err(io::Error::last_os_error())
+            }
+        }
+    }
+
+    /// Get current memory statistics (not supported on non-Unix platforms)
+    ///
+    /// # Errors
+    ///
+    /// Returns an error on non-Unix platforms where memory statistics are not supported.
+    #[cfg(not(unix))]
+    pub fn current() -> Result<Self, io::Error> {
+        Err(io::Error::new(
+            io::ErrorKind::Unsupported,
+            "Memory statistics not supported on this platform",
+        ))
+    }
+
+    /// Print memory statistics in a human-readable format
+    #[allow(clippy::cast_precision_loss)]
+    pub fn print(&self) {
+        let mrss_mb = self.max_rss_bytes as f64 / 1024.0 / 1024.0;
+
+        println!("Maximum RSS: {} bytes ({:.2} MB)", self.max_rss_bytes, mrss_mb);
+        println!();
+    }
+
+    /// Retrieve and print memory usage statistics
+    pub fn print_memory_usage() {
+        match Self::current() {
+            Ok(stats) => stats.print(),
+            Err(e) => eprintln!("Warning: Could not retrieve memory statistics: {e}"),
+        }
+    }
+}

data/rust/rubydex/src/stats/timer.rs

@@ -0,0 +1,126 @@
+use std::sync::Mutex;
+use std::time::{Duration, Instant};
+
+/// Generates a global timer for measuring performance across different phases of execution in the main thread.
+///
+/// This macro creates:
+/// - A `Timer` struct with fields for each defined phase
+/// - A global `TIMER` static for tracking measurements
+/// - A `time_it!` macro to measure and record individual phase durations
+///
+/// The timer is only created when running with the `--stats` flag.
+///
+/// Usage:
+/// 1. To add a new phase, add an entry to the `make_timer!` invocation at the bottom of this file
+/// 2. Wrap code blocks with `time_it!(phase_name, { ... })` to measure them
+macro_rules! make_timer {
+    (
+        $(
+            $phase:ident, $label:literal;
+        )*
+    ) => {
+        #[derive(Clone)]
+        pub struct Timer {
+            start_time: Instant,
+            $(
+                pub $phase: Duration,
+            )*
+        }
+
+        pub static TIMER: Mutex<Option<Timer>> = Mutex::new(None);
+
+        impl Default for Timer {
+            fn default() -> Self {
+                Self::new()
+            }
+        }
+
+        impl Timer {
+            #[must_use]
+            pub fn new() -> Self {
+                Self {
+                    start_time: Instant::now(),
+                    $(
+                        $phase: Duration::ZERO,
+                    )*
+                }
+            }
+
+            pub fn set_global_timer(timer: Timer) {
+                *TIMER.lock().unwrap() = Some(timer);
+            }
+
+            pub fn print_breakdown() {
+                if let Some(ref timer) = *TIMER.lock().unwrap() {
+                    macro_rules! format_breakdown {
+                        ($name:expr, $duration:expr, $total:expr) => {
+                            format!(
+                                "{:<16} {:8.3}s ({:5.1}%)",
+                                $name,
+                                $duration.as_secs_f64(),
+                                $duration.as_secs_f64() * 100.0 / $total.as_secs_f64()
+                            )
+                        };
+                    }
+
+                    let total_duration = timer.start_time.elapsed();
+                    let mut accounted_time = Duration::ZERO;
+                    $(
+                        accounted_time += timer.$phase;
+                    )*
+                    let cleanup = total_duration - accounted_time;
+
+                    println!();
+                    println!("Timing breakdown");
+
+                    $(
+                        if timer.$phase != Duration::ZERO {
+                            println!("  {}", format_breakdown!($label, timer.$phase, total_duration));
+                        }
+                    )*
+
+                    println!("  {}", format_breakdown!("Cleanup", cleanup, total_duration));
+                    println!("  Total:           {:8.3}s", total_duration.as_secs_f64());
+                    println!();
+                }
+            }
+        }
+
+        #[macro_export]
+        macro_rules! time_it {
+            $(
+                ($phase, $body:block) => {
+                    {
+                        let timer_enabled = {
+                            let guard = $crate::stats::timer::TIMER.lock().unwrap();
+                            guard.is_some()
+                        };
+
+                        if timer_enabled {
+                            let start = std::time::Instant::now();
+                            let result = $body;
+                            let elapsed = start.elapsed();
+
+                            if let Some(ref mut timer) = *$crate::stats::timer::TIMER.lock().unwrap() {
+                                timer.$phase = elapsed;
+                            }
+                            result
+                        } else {
+                            $body
+                        }
+                    }
+                };
+            )*
+        }
+
+        pub use time_it;
+    };
+}
+
+make_timer! {
+    setup, "Initialization";
+    listing, "Listing";
+    indexing, "Indexing";
+    resolution, "Resolution";
+    querying, "Querying";
+}

data/rust/rubydex/src/stats.rs

@@ -0,0 +1,9 @@
+pub mod memory;
+pub mod timer;
+
+/// Helper function to compute percentage
+#[allow(clippy::cast_precision_loss)]
+#[must_use]
+pub fn percentage(numerator: usize, denominator: usize) -> f64 {
+    (numerator as f64 / denominator as f64) * 100.0
+}

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

@@ -0,0 +1,226 @@
+use super::normalize_indentation;
+use std::fs;
+use std::path::{Path, PathBuf};
+use tempfile::TempDir;
+
+#[derive(Debug)]
+pub struct Context {
+    _root: TempDir,
+    absolute_path: PathBuf,
+}
+
+/// Executes a closure with a new temporary context, ensuring cleanup afterwards.
+///
+/// # Examples
+///
+/// ```
+/// use rubydex::test_utils::with_context;
+///
+/// with_context(|context| {
+///     context.touch("foo.rb");
+/// });
+/// ```
+pub fn with_context<F, R>(f: F) -> R
+where
+    F: FnOnce(&Context) -> R,
+{
+    let context = Context::new();
+    f(&context)
+}
+
+impl Context {
+    /// Creates a new test context in a temporary directory
+    ///
+    /// # Panics
+    ///
+    /// Panics if the temp directory cannot be created.
+    #[must_use]
+    pub fn new() -> Self {
+        let root = tempfile::tempdir().expect("failed to create temp dir");
+        let absolute_path = fs::canonicalize(root.path()).unwrap();
+        Self {
+            _root: root,
+            absolute_path,
+        }
+    }
+
+    /// Returns the absolute path to the temp directory as a `PathBuf`
+    ///
+    /// # Panics
+    ///
+    /// Panics if the path cannot be canonicalized.
+    #[must_use]
+    pub fn absolute_path(&self) -> PathBuf {
+        self.absolute_path.clone()
+    }
+
+    /// Returns the absolute path to the relative path
+    ///
+    /// # Panics
+    ///
+    /// Panics if the path cannot be canonicalized.
+    #[must_use]
+    pub fn absolute_path_to(&self, relative: &str) -> PathBuf {
+        self.absolute_path.join(relative)
+    }
+
+    /// Returns the path of `absolute` relative to the context root.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the provided path cannot be canonicalized or is not under the root.
+    #[must_use]
+    pub fn relative_path_to<P: AsRef<Path>>(&self, absolute: P) -> PathBuf {
+        absolute
+            .as_ref()
+            .strip_prefix(self.absolute_path())
+            .unwrap()
+            .to_path_buf()
+    }
+
+    /// Create a directory (and parents) relative to the root
+    ///
+    /// # Panics
+    ///
+    /// Panics if the directory cannot be created.
+    pub fn mkdir<P: AsRef<Path>>(&self, relative: P) {
+        let dir = self.absolute_path().join(relative);
+        fs::create_dir_all(dir).unwrap();
+    }
+
+    /// Touch a file relative to the root, creating parent directories as needed
+    ///
+    /// # Panics
+    ///
+    /// Panics if the file cannot be created.
+    pub fn touch<P: AsRef<Path>>(&self, relative: P) {
+        self.write(relative, "");
+    }
+
+    /// Read a file relative to the root
+    ///
+    /// # Panics
+    ///
+    /// Panics if the file cannot be read.
+    #[must_use]
+    pub fn read<P: AsRef<Path>>(&self, relative: P) -> String {
+        fs::read_to_string(self.absolute_path().join(relative)).unwrap()
+    }
+
+    /// Write a file relative to the root, creating parent directories as needed
+    ///
+    /// # Panics
+    ///
+    /// Panics if the file cannot be created.
+    pub fn write<P: AsRef<Path>>(&self, relative: P, content: &str) {
+        let path = self.absolute_path().join(relative);
+        if let Some(parent) = path.parent() {
+            fs::create_dir_all(parent).unwrap();
+        }
+        let content = normalize_indentation(content);
+        fs::write(path, content).unwrap();
+    }
+}
+
+impl Default for Context {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+// no local normalize_indentation; shared via super::normalize_indentation
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn creates_and_cleans_up_temp_dir() {
+        let context = Context::new();
+        let root = context.absolute_path();
+
+        assert!(root.exists());
+
+        drop(context);
+
+        // After drop, the directory should not exist anymore
+        assert!(!root.exists());
+    }
+
+    #[test]
+    fn mkdir_creates_directories() {
+        let context = Context::new();
+
+        assert!(!context.absolute_path_to("foo").exists());
+        context.mkdir("foo");
+        assert!(context.absolute_path_to("foo").exists());
+
+        assert!(!context.absolute_path_to("bar/baz").exists());
+        context.mkdir("bar/baz");
+        assert!(context.absolute_path_to("bar/baz").exists());
+    }
+
+    #[test]
+    fn touch_creates_files() {
+        let context = Context::new();
+
+        assert!(!context.absolute_path_to("foo/bar.rb").exists());
+        context.touch("foo/bar.rb");
+        assert!(context.absolute_path_to("foo/bar.rb").exists());
+
+        assert!(!context.absolute_path_to("baz/qux.rb").exists());
+        context.touch("baz/qux.rb");
+        assert!(context.absolute_path_to("baz/qux.rb").exists());
+    }
+
+    #[test]
+    fn write_creates_files_with_content() {
+        let context = Context::new();
+
+        context.write("foo/bar.rb", "class Foo; end\n");
+        assert_eq!(context.read("foo/bar.rb"), "class Foo; end\n");
+
+        context.write("baz/qux.rb", "class Baz; end\n");
+        assert_eq!(context.read("baz/qux.rb"), "class Baz; end\n");
+    }
+
+    #[test]
+    fn write_creates_files_with_content_and_normalizes_indentation() {
+        let context = Context::new();
+
+        context.write("foo/bar.rb", {
+            "
+            class Foo
+              def bar
+                puts 'baz'
+              end
+            end
+            "
+        });
+
+        assert_eq!(
+            context.read("foo/bar.rb"),
+            normalize_indentation({
+                "
+                class Foo
+                  def bar
+                    puts 'baz'
+                  end
+                end
+                "
+            }),
+        );
+    }
+
+    #[test]
+    fn with_context_creates_and_cleans_up_temp_dir() {
+        let root = with_context(|context| {
+            let root = context.absolute_path();
+            assert!(root.exists());
+            context.touch("foo.rb");
+            root
+        });
+
+        assert!(!root.exists());
+    }
+}

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

@@ -0,0 +1,229 @@
+use line_index::LineIndex;
+
+use super::normalize_indentation;
+use crate::indexing::local_graph::LocalGraph;
+use crate::indexing::ruby_indexer::RubyIndexer;
+use crate::model::graph::Graph;
+use crate::model::ids::UriId;
+use crate::offset::Offset;
+use crate::position::Position;
+use crate::resolution::Resolver;
+
+#[derive(Default)]
+pub struct GraphTest {
+    graph: Graph,
+}
+
+impl GraphTest {
+    #[must_use]
+    pub fn new() -> Self {
+        Self { graph: Graph::new() }
+    }
+
+    #[must_use]
+    pub fn graph(&self) -> &Graph {
+        &self.graph
+    }
+
+    #[must_use]
+    fn index_source(uri: &str, source: &str) -> LocalGraph {
+        let mut indexer = RubyIndexer::new(uri.to_string(), source);
+        indexer.index();
+        indexer.local_graph()
+    }
+
+    pub fn index_uri(&mut self, uri: &str, source: &str) {
+        let source = normalize_indentation(source);
+        let local_index = Self::index_source(uri, &source);
+        self.graph.update(local_index);
+    }
+
+    pub fn delete_uri(&mut self, uri: &str) {
+        self.graph.delete_uri(uri);
+    }
+
+    pub fn resolve(&mut self) {
+        let mut resolver = Resolver::new(&mut self.graph);
+        resolver.resolve_all();
+    }
+
+    /// 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, u32, u32) {
+        let (uri, start_position, end_position) = Self::parse_location_positions(location);
+        let line_index = self.line_index_for(uri.as_str());
+
+        (
+            uri,
+            line_index
+                .offset(start_position)
+                .unwrap_or_else(|| panic!("Invalid start position {}:{}", start_position.line, start_position.col))
+                .into(),
+            line_index
+                .offset(end_position)
+                .unwrap_or_else(|| panic!("Invalid end position {}:{}", end_position.line, end_position.col))
+                .into(),
+        )
+    }
+
+    /// Asserts that the given offset matches the expected offset, providing clear error messages
+    /// with line:column positions when they don't match
+    ///
+    /// # Panics
+    ///
+    /// Panics if the source is not found for the URI, byte offsets are invalid, or if the actual
+    /// offset doesn't match the expected offset.
+    pub fn assert_offset_matches(
+        &self,
+        uri: &str,
+        actual_offset: &Offset,
+        expected_start: u32,
+        expected_end: u32,
+        context_message: &str,
+        location: &str,
+    ) {
+        let line_index = self.line_index_for(uri);
+
+        if actual_offset.start() == expected_start && actual_offset.end() == expected_end {
+            return;
+        }
+
+        let actual_start_pos = line_index.line_col(actual_offset.start().into());
+        let actual_end_pos = line_index.line_col(actual_offset.end().into());
+        let expected_start_pos = line_index.line_col(expected_start.into());
+        let expected_end_pos = line_index.line_col(expected_end.into());
+
+        assert!(
+            actual_offset.start() == expected_start,
+            "Start position mismatch for {} at {}\n  actual:   {}\n  expected: {}",
+            context_message,
+            location,
+            Self::format_position(actual_start_pos),
+            Self::format_position(expected_start_pos)
+        );
+
+        assert!(
+            actual_offset.end() == expected_end,
+            "End position mismatch for {} at {}\n  actual:   {}\n  expected: {}",
+            context_message,
+            location,
+            Self::format_position(actual_end_pos),
+            Self::format_position(expected_end_pos)
+        );
+    }
+
+    fn line_index_for(&self, uri: &str) -> &LineIndex {
+        let uri_id = UriId::from(uri);
+        let document = self.graph.documents().get(&uri_id).unwrap();
+        document.line_index()
+    }
+
+    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,
+                col: start_column,
+            },
+            Position {
+                line: end_line,
+                col: end_column,
+            },
+        )
+    }
+
+    fn parse_number(value: &str, field: &str, location: &str) -> u32 {
+        value
+            .parse()
+            .unwrap_or_else(|_| panic!("Invalid {field} '{value}' in location {location}"))
+    }
+
+    fn format_position(position: Position) -> String {
+        format!("line {}, column {}", position.line, position.col)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_index_uri_with_single_line() {
+        let mut context = GraphTest::new();
+
+        context.index_uri("file://method.rb", "class Foo; end");
+        context.resolve();
+
+        let foo_defs = context.graph.get("Foo").unwrap();
+        assert_eq!(foo_defs.len(), 1);
+        assert_eq!(foo_defs[0].offset().start(), 0);
+        assert_eq!(foo_defs[0].offset().end(), 14);
+    }
+
+    #[test]
+    fn test_index_uri_with_multiple_lines() {
+        let mut context = GraphTest::new();
+
+        context.index_uri("file://method.rb", {
+            "
+            class Foo
+              class Bar; end
+            end
+            "
+        });
+
+        context.resolve();
+
+        let foo_defs = context.graph.get("Foo").unwrap();
+        assert_eq!(foo_defs.len(), 1);
+        assert_eq!(foo_defs[0].offset().start(), 0);
+        assert_eq!(foo_defs[0].offset().end(), 30);
+
+        let bar_defs = context.graph.get("Foo::Bar").unwrap();
+        assert_eq!(bar_defs.len(), 1);
+        assert_eq!(bar_defs[0].offset().start(), 12);
+        assert_eq!(bar_defs[0].offset().end(), 26);
+    }
+
+    #[test]
+    fn test_index_uri_with_new_lines() {
+        let mut context = GraphTest::new();
+
+        context.index_uri("file://method.rb", "\n\nclass Foo; end");
+        context.resolve();
+
+        let foo_defs = context.graph.get("Foo").unwrap();
+        assert_eq!(foo_defs.len(), 1);
+        assert_eq!(foo_defs[0].offset().start(), 2);
+        assert_eq!(foo_defs[0].offset().end(), 16);
+    }
+}