rubydex 0.1.0.beta12-aarch64-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/orphan_report.rs

@@ -0,0 +1,264 @@
+use std::collections::HashSet;
+use std::io::Write;
+
+use crate::model::declaration::Declaration;
+use crate::model::definitions::Definition;
+use crate::model::graph::Graph;
+use crate::model::ids::{DefinitionId, NameId, StringId};
+use crate::model::name::{NameRef, ParentScope};
+
+impl Graph {
+    /// Writes a report of orphan definitions (definitions not linked to any declaration).
+    ///
+    /// Format: `type\tconcatenated_name\tlocation` (TSV)
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if writing fails.
+    pub fn write_orphan_report(&self, writer: &mut impl Write) -> std::io::Result<()> {
+        // Collect all definition IDs that are linked to declarations
+        let linked_definition_ids: HashSet<&DefinitionId> = self
+            .declarations()
+            .values()
+            .flat_map(Declaration::definitions)
+            .collect();
+
+        // Find orphan definitions
+        let mut orphans: Vec<_> = self
+            .definitions()
+            .iter()
+            .filter(|(id, _)| !linked_definition_ids.contains(id))
+            .collect();
+
+        // Sort by type, then by location for consistent output
+        orphans.sort_by(|(_, a), (_, b)| {
+            a.kind()
+                .cmp(b.kind())
+                .then_with(|| a.uri_id().cmp(b.uri_id()))
+                .then_with(|| a.offset().cmp(b.offset()))
+        });
+
+        for (_, definition) in orphans {
+            let kind = definition.kind();
+            let name = match definition.name_id().copied() {
+                Some(id) => self.build_concatenated_name_from_name(id),
+                None => self.build_concatenated_name_from_lexical_nesting(definition),
+            };
+            let location = self.definition_location(definition);
+
+            writeln!(writer, "{kind}\t{name}\t{location}")?;
+        }
+
+        Ok(())
+    }
+
+    /// Walks the Name system's `parent_scope` chain to reconstruct the constant path.
+    /// Falls back to `nesting` for enclosing scope context when there is no explicit parent scope.
+    ///
+    /// Note: this produces a concatenated name by piecing together name parts, not a properly
+    /// resolved qualified name.
+    pub(crate) fn build_concatenated_name_from_name(&self, name_id: NameId) -> String {
+        let Some(name_ref) = self.names().get(&name_id) else {
+            return "<unknown>".to_string();
+        };
+        let simple_name = self.string_id_to_string(*name_ref.str());
+
+        match name_ref.parent_scope() {
+            ParentScope::Some(parent_id) | ParentScope::Attached(parent_id) => {
+                let parent_name = self.build_concatenated_name_from_name(*parent_id);
+                format!("{parent_name}::{simple_name}")
+            }
+            ParentScope::TopLevel => format!("::{simple_name}"),
+            ParentScope::None => {
+                let prefix = name_ref
+                    .nesting()
+                    .as_ref()
+                    .map(|nesting_id| self.build_nesting_prefix(*nesting_id))
+                    .unwrap_or_default();
+
+                if prefix.is_empty() {
+                    simple_name
+                } else {
+                    format!("{prefix}::{simple_name}")
+                }
+            }
+        }
+    }
+
+    /// Resolves the enclosing nesting `NameId` to a string prefix.
+    /// For resolved names, uses the declaration's fully qualified name.
+    /// For unresolved names, recursively walks the name chain.
+    fn build_nesting_prefix(&self, nesting_id: NameId) -> String {
+        let Some(name_ref) = self.names().get(&nesting_id) else {
+            return String::new();
+        };
+        match name_ref {
+            NameRef::Resolved(resolved) => self
+                .declarations()
+                .get(resolved.declaration_id())
+                .map_or_else(String::new, |decl| decl.name().to_string()),
+            NameRef::Unresolved(_) => self.build_concatenated_name_from_name(nesting_id),
+        }
+    }
+
+    /// Builds a concatenated name for non-constant definitions by walking the `lexical_nesting_id` chain.
+    ///
+    /// Note: this pieces together name parts from the lexical nesting, not a properly resolved
+    /// qualified name.
+    pub(crate) fn build_concatenated_name_from_lexical_nesting(&self, definition: &Definition) -> String {
+        let simple_name = self.string_id_to_string(self.definition_string_id(definition));
+
+        // Collect enclosing nesting names from inner to outer
+        let mut nesting_parts = Vec::new();
+        let mut current_nesting = *definition.lexical_nesting_id();
+
+        while let Some(nesting_id) = current_nesting {
+            let Some(nesting_def) = self.definitions().get(&nesting_id) else {
+                break;
+            };
+            nesting_parts.push(self.string_id_to_string(self.definition_string_id(nesting_def)));
+            current_nesting = *nesting_def.lexical_nesting_id();
+        }
+
+        if nesting_parts.is_empty() {
+            return simple_name;
+        }
+
+        // Reverse to get outer-to-inner order for the prefix
+        nesting_parts.reverse();
+        let prefix = nesting_parts.join("::");
+
+        let separator = match definition {
+            Definition::Method(_)
+            | Definition::AttrAccessor(_)
+            | Definition::AttrReader(_)
+            | Definition::AttrWriter(_)
+            | Definition::MethodAlias(_)
+            | Definition::MethodVisibility(_)
+            | Definition::InstanceVariable(_) => "#",
+            Definition::Class(_)
+            | Definition::SingletonClass(_)
+            | Definition::Module(_)
+            | Definition::Constant(_)
+            | Definition::ConstantAlias(_)
+            | Definition::ConstantVisibility(_)
+            | Definition::GlobalVariable(_)
+            | Definition::ClassVariable(_)
+            | Definition::GlobalVariableAlias(_) => "::",
+        };
+
+        format!("{prefix}{separator}{simple_name}")
+    }
+
+    /// Converts a `StringId` to its string value.
+    fn string_id_to_string(&self, string_id: StringId) -> String {
+        self.strings().get(&string_id).unwrap().to_string()
+    }
+
+    /// Get location in the format of `uri#L<line>` for a definition.
+    /// The format is clickable in VS Code.
+    pub(crate) fn definition_location(&self, definition: &Definition) -> String {
+        let uri_id = definition.uri_id();
+
+        let Some(document) = self.documents().get(uri_id) else {
+            return format!("{uri_id}:<unknown>");
+        };
+
+        let uri = document.uri();
+        let line_index = document.line_index();
+        let start = line_index.line_col(definition.offset().start().into());
+        format!("{uri}#L{}", start.line + 1)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::test_utils::GraphTest;
+
+    #[test]
+    fn build_concatenated_name_from_name_for_constants() {
+        let cases = vec![
+            ("class Foo; end", "Foo"),
+            ("module Foo; class Bar; end; end", "Foo::Bar"),
+            ("module Foo; module Bar; class Baz; end; end; end", "Foo::Bar::Baz"),
+        ];
+
+        for (source, expected_name) in cases {
+            let mut context = GraphTest::new();
+            context.index_uri("file:///test.rb", source);
+            context.resolve();
+
+            let definitions = context.graph().get(expected_name).unwrap();
+            let definition = definitions.first().unwrap();
+            let name_id = *definition.name_id().unwrap();
+            let actual = context.graph().build_concatenated_name_from_name(name_id);
+
+            assert_eq!(actual, expected_name, "For source: {source}");
+        }
+    }
+
+    #[test]
+    fn build_concatenated_name_from_lexical_nesting_for_methods() {
+        let cases = vec![
+            ("class Foo; def bar; end; end", "Foo#bar()"),
+            ("module Foo; class Bar; def baz; end; end; end", "Foo::Bar#baz()"),
+            ("def bar; end", "bar()"),
+        ];
+
+        for (source, expected_name) in cases {
+            let mut context = GraphTest::new();
+            // Index without resolution so methods remain orphans
+            context.index_uri("file:///test.rb", source);
+
+            let definition = context
+                .graph()
+                .definitions()
+                .values()
+                .find(|d| d.kind() == "Method" && d.name_id().is_none())
+                .unwrap_or_else(|| panic!("No Method definition without name_id found for source: {source}"));
+
+            let actual = context.graph().build_concatenated_name_from_lexical_nesting(definition);
+            assert_eq!(actual, expected_name, "For source: {source}");
+        }
+    }
+
+    #[test]
+    fn build_concatenated_name_from_lexical_nesting_for_instance_variables() {
+        let mut context = GraphTest::new();
+        context.index_uri("file:///test.rb", "class Foo; def initialize; @ivar = 1; end; end");
+
+        let definition = context
+            .graph()
+            .definitions()
+            .values()
+            .find(|d| d.kind() == "InstanceVariable")
+            .unwrap();
+
+        let actual = context.graph().build_concatenated_name_from_lexical_nesting(definition);
+        assert_eq!(actual, "Foo::initialize()#@ivar");
+    }
+
+    #[test]
+    fn definition_location_uses_clickable_uri_fragment() {
+        let mut context = GraphTest::new();
+        context.index_uri(
+            "file:///foo.rb",
+            "
+            class Foo
+              def bar
+              end
+            end
+            ",
+        );
+
+        let definition = context
+            .graph()
+            .definitions()
+            .values()
+            .find(|d| d.kind() == "Method")
+            .unwrap();
+
+        let actual = context.graph().definition_location(definition);
+        assert_eq!(actual, "file:///foo.rb#L2");
+    }
+}

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

@@ -0,0 +1,127 @@
+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";
+    integrity_check, "Integrity check";
+    querying, "Querying";
+}

data/rust/rubydex/src/stats.rs

@@ -0,0 +1,11 @@
+pub mod memory;
+// TODO: When the rubydex is stable enough, turn this into a debug-only feature or revisit if we still need it.
+pub mod orphan_report;
+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());
+    }
+}