rubydex 0.1.0.beta11 → 0.1.0.beta13

data/rust/rubydex/src/main.rs

@@ -1,160 +1,160 @@
-use clap::{Parser, ValueEnum};
-use std::mem;
-
-use rubydex::{
-    indexing, integrity, listing,
-    model::graph::Graph,
-    resolution::Resolver,
-    stats::{
-        memory::MemoryStats,
-        timer::{Timer, time_it},
-    },
-    visualization::dot,
-};
-
-#[derive(Parser, Debug)]
-#[command(name = "rubydex_cli", about = "A Static Analysis Toolkit for Ruby", version)]
-#[allow(clippy::struct_excessive_bools)]
-struct Args {
-    #[arg(value_name = "PATHS", default_value = ".")]
-    paths: Vec<String>,
-
-    #[arg(long = "stop-after", help = "Stop after the given stage")]
-    stop_after: Option<StopAfter>,
-
-    #[arg(long = "visualize")]
-    visualize: bool,
-
-    #[arg(long = "stats", help = "Show detailed performance statistics")]
-    stats: bool,
-
-    #[arg(long = "check-integrity", help = "Check the integrity of the graph after resolution")]
-    check_integrity: bool,
-
-    #[arg(
-        long = "report-orphans",
-        value_name = "PATH",
-        num_args = 0..=1,
-        require_equals = true,
-        default_missing_value = "/tmp/rubydex-orphan-report.txt",
-        help = "Write orphan definitions report to specified file"
-    )]
-    report_orphans: Option<String>,
-}
-
-#[derive(Debug, Clone, ValueEnum)]
-enum StopAfter {
-    Listing,
-    Indexing,
-    Resolution,
-}
-
-fn exit(print_stats: bool) {
-    if print_stats {
-        Timer::print_breakdown();
-        MemoryStats::print_memory_usage();
-    }
-
-    std::process::exit(0);
-}
-
-fn main() {
-    let args = Args::parse();
-
-    if args.stats {
-        Timer::set_global_timer(Timer::new());
-    }
-
-    // Listing
-
-    let (file_paths, errors) = time_it!(listing, { listing::collect_file_paths(args.paths) });
-
-    for error in errors {
-        eprintln!("{error}");
-    }
-
-    if let Some(StopAfter::Listing) = args.stop_after {
-        return exit(args.stats);
-    }
-
-    // Indexing
-
-    let mut graph = Graph::new();
-    let errors = time_it!(indexing, { indexing::index_files(&mut graph, file_paths) });
-
-    for error in errors {
-        eprintln!("{error}");
-    }
-
-    if let Some(StopAfter::Indexing) = args.stop_after {
-        return exit(args.stats);
-    }
-
-    // Resolution
-
-    time_it!(resolution, {
-        let mut resolver = Resolver::new(&mut graph);
-        resolver.resolve();
-    });
-
-    if let Some(StopAfter::Resolution) = args.stop_after {
-        return exit(args.stats);
-    }
-
-    // Integrity check
-    if args.check_integrity {
-        let errors = time_it!(integrity_check, { integrity::check_integrity(&graph) });
-
-        if errors.is_empty() {
-            println!("Integrity check passed: no issues found");
-        } else {
-            eprintln!("Integrity check found {} issue(s):", errors.len());
-
-            for error in &errors {
-                eprintln!("  - {error}");
-            }
-
-            std::process::exit(1);
-        }
-    }
-
-    // Querying
-
-    if args.stats {
-        time_it!(querying, {
-            graph.print_query_statistics();
-        });
-    }
-
-    if args.stats {
-        Timer::print_breakdown();
-        MemoryStats::print_memory_usage();
-    }
-
-    // Orphan report
-    if let Some(ref path) = args.report_orphans {
-        match std::fs::File::create(path) {
-            Ok(mut file) => {
-                if let Err(e) = graph.write_orphan_report(&mut file) {
-                    eprintln!("Failed to write orphan report: {e}");
-                } else {
-                    println!("Orphan report written to {path}");
-                }
-            }
-            Err(e) => eprintln!("Failed to create orphan report file: {e}"),
-        }
-    }
-
-    // Generate visualization or print statistics
-    if args.visualize {
-        println!("{}", dot::generate(&graph));
-    } else {
-        println!("Indexed {} files", graph.documents().len());
-        println!("Found {} names", graph.declarations().len());
-        println!("Found {} definitions", graph.definitions().len());
-        println!("Found {} URIs", graph.documents().len());
-    }
-
-    // Forget the graph so we don't have to wait for deallocation and let the system reclaim the memory at exit
-    mem::forget(graph);
-}
+use clap::{Parser, ValueEnum};
+use std::{collections::HashSet, mem};
+
+use rubydex::{
+    indexing, integrity, listing,
+    model::graph::Graph,
+    resolution::Resolver,
+    stats::{
+        memory::MemoryStats,
+        timer::{Timer, time_it},
+    },
+    visualization::dot,
+};
+
+#[derive(Parser, Debug)]
+#[command(name = "rubydex_cli", about = "A Static Analysis Toolkit for Ruby", version)]
+#[allow(clippy::struct_excessive_bools)]
+struct Args {
+    #[arg(value_name = "PATHS", default_value = ".")]
+    paths: Vec<String>,
+
+    #[arg(long = "stop-after", help = "Stop after the given stage")]
+    stop_after: Option<StopAfter>,
+
+    #[arg(long = "visualize")]
+    visualize: bool,
+
+    #[arg(long = "stats", help = "Show detailed performance statistics")]
+    stats: bool,
+
+    #[arg(long = "check-integrity", help = "Check the integrity of the graph after resolution")]
+    check_integrity: bool,
+
+    #[arg(
+        long = "report-orphans",
+        value_name = "PATH",
+        num_args = 0..=1,
+        require_equals = true,
+        default_missing_value = "/tmp/rubydex-orphan-report.txt",
+        help = "Write orphan definitions report to specified file"
+    )]
+    report_orphans: Option<String>,
+}
+
+#[derive(Debug, Clone, ValueEnum)]
+enum StopAfter {
+    Listing,
+    Indexing,
+    Resolution,
+}
+
+fn exit(print_stats: bool) {
+    if print_stats {
+        Timer::print_breakdown();
+        MemoryStats::print_memory_usage();
+    }
+
+    std::process::exit(0);
+}
+
+fn main() {
+    let args = Args::parse();
+
+    if args.stats {
+        Timer::set_global_timer(Timer::new());
+    }
+
+    // Listing
+
+    let (file_paths, errors) = time_it!(listing, { listing::collect_file_paths(args.paths, &HashSet::new()) });
+
+    for error in errors {
+        eprintln!("{error}");
+    }
+
+    if let Some(StopAfter::Listing) = args.stop_after {
+        return exit(args.stats);
+    }
+
+    // Indexing
+
+    let mut graph = Graph::new();
+    let errors = time_it!(indexing, { indexing::index_files(&mut graph, file_paths) });
+
+    for error in errors {
+        eprintln!("{error}");
+    }
+
+    if let Some(StopAfter::Indexing) = args.stop_after {
+        return exit(args.stats);
+    }
+
+    // Resolution
+
+    time_it!(resolution, {
+        let mut resolver = Resolver::new(&mut graph);
+        resolver.resolve();
+    });
+
+    if let Some(StopAfter::Resolution) = args.stop_after {
+        return exit(args.stats);
+    }
+
+    // Integrity check
+    if args.check_integrity {
+        let errors = time_it!(integrity_check, { integrity::check_integrity(&graph) });
+
+        if errors.is_empty() {
+            println!("Integrity check passed: no issues found");
+        } else {
+            eprintln!("Integrity check found {} issue(s):", errors.len());
+
+            for error in &errors {
+                eprintln!("  - {error}");
+            }
+
+            std::process::exit(1);
+        }
+    }
+
+    // Querying
+
+    if args.stats {
+        time_it!(querying, {
+            graph.print_query_statistics();
+        });
+    }
+
+    if args.stats {
+        Timer::print_breakdown();
+        MemoryStats::print_memory_usage();
+    }
+
+    // Orphan report
+    if let Some(ref path) = args.report_orphans {
+        match std::fs::File::create(path) {
+            Ok(mut file) => {
+                if let Err(e) = graph.write_orphan_report(&mut file) {
+                    eprintln!("Failed to write orphan report: {e}");
+                } else {
+                    println!("Orphan report written to {path}");
+                }
+            }
+            Err(e) => eprintln!("Failed to create orphan report file: {e}"),
+        }
+    }
+
+    // Generate visualization or print statistics
+    if args.visualize {
+        println!("{}", dot::generate(&graph));
+    } else {
+        println!("Indexed {} files", graph.documents().len());
+        println!("Found {} names", graph.declarations().len());
+        println!("Found {} definitions", graph.definitions().len());
+        println!("Found {} URIs", graph.documents().len());
+    }
+
+    // Forget the graph so we don't have to wait for deallocation and let the system reclaim the memory at exit
+    mem::forget(graph);
+}

data/rust/rubydex/src/model/built_in.rs

@@ -0,0 +1,83 @@
+use std::sync::LazyLock;
+
+use url::Url;
+
+use crate::{
+    indexing::{self, LanguageId},
+    model::{
+        declaration::{ClassDeclaration, Declaration, Namespace},
+        graph::Graph,
+        ids::DeclarationId,
+    },
+};
+
+pub static KERNEL_ID: LazyLock<DeclarationId> = LazyLock::new(|| DeclarationId::from("Kernel"));
+pub static BASIC_OBJECT_ID: LazyLock<DeclarationId> = LazyLock::new(|| DeclarationId::from("BasicObject"));
+pub static OBJECT_ID: LazyLock<DeclarationId> = LazyLock::new(|| DeclarationId::from("Object"));
+pub static MODULE_ID: LazyLock<DeclarationId> = LazyLock::new(|| DeclarationId::from("Module"));
+pub static CLASS_ID: LazyLock<DeclarationId> = LazyLock::new(|| DeclarationId::from("Class"));
+
+/// Adds core classes and modules data to the graph so that resolution can provide correct results even when not
+/// indexing the complete RBS core definitions
+///
+/// # Panics
+///
+/// Will panic if the built-in URI is invalid
+pub fn add_built_in_data(graph: &mut Graph) {
+    // We need definitions to ensure that ancestor linearization happens naturally through the algorithm. Trying to set
+    // ancestors directly on declarations doesn't work because the algorithm erases the ancestors and there are no
+    // definitions to inform it of the superclasses and mixins.
+    let uri = Url::parse("rubydex:built-in").unwrap();
+    let source = r"
+      class BasicObject
+      end
+
+      module Kernel
+      end
+
+      class Object < BasicObject
+        include Kernel
+      end
+
+      class Module < Object
+      end
+
+      class Class < Module
+      end
+    ";
+    indexing::index_source(graph, uri.as_ref(), source, &LanguageId::Rbs);
+
+    // Creating declarations eagerly is still necessary because we need to associate correct ownership data no matter in
+    // what order we discover classes and modules
+    let declarations = graph.declarations_mut();
+
+    // Built-in declarations that always exist in the Ruby object model
+    declarations.insert(
+        *BASIC_OBJECT_ID,
+        Declaration::Namespace(Namespace::Class(Box::new(ClassDeclaration::new(
+            "BasicObject".to_string(),
+            *OBJECT_ID,
+        )))),
+    );
+    declarations.insert(
+        *OBJECT_ID,
+        Declaration::Namespace(Namespace::Class(Box::new(ClassDeclaration::new(
+            "Object".to_string(),
+            *OBJECT_ID,
+        )))),
+    );
+    declarations.insert(
+        *MODULE_ID,
+        Declaration::Namespace(Namespace::Class(Box::new(ClassDeclaration::new(
+            "Module".to_string(),
+            *OBJECT_ID,
+        )))),
+    );
+    declarations.insert(
+        *CLASS_ID,
+        Declaration::Namespace(Namespace::Class(Box::new(ClassDeclaration::new(
+            "Class".to_string(),
+            *OBJECT_ID,
+        )))),
+    );
+}

data/rust/rubydex/src/model/comment.rs

@@ -1,24 +1,24 @@
-use crate::offset::Offset;
-
-#[derive(Debug, Clone)]
-pub struct Comment {
-    offset: Offset,
-    string: String,
-}
-
-impl Comment {
-    #[must_use]
-    pub fn new(offset: Offset, string: String) -> Self {
-        Self { offset, string }
-    }
-
-    #[must_use]
-    pub fn offset(&self) -> &Offset {
-        &self.offset
-    }
-
-    #[must_use]
-    pub fn string(&self) -> &String {
-        &self.string
-    }
-}
+use crate::offset::Offset;
+
+#[derive(Debug, Clone)]
+pub struct Comment {
+    offset: Offset,
+    string: String,
+}
+
+impl Comment {
+    #[must_use]
+    pub fn new(offset: Offset, string: String) -> Self {
+        Self { offset, string }
+    }
+
+    #[must_use]
+    pub fn offset(&self) -> &Offset {
+        &self.offset
+    }
+
+    #[must_use]
+    pub fn string(&self) -> &String {
+        &self.string
+    }
+}