rubydex 0.3.0 → 0.4.1

data/rbi/rubydex.rbi

@@ -175,22 +175,114 @@ class Rubydex::AttrAccessorDefinition < Rubydex::Definition; end
 class Rubydex::AttrReaderDefinition < Rubydex::Definition; end
 class Rubydex::AttrWriterDefinition < Rubydex::Definition; end
 class Rubydex::ClassVariableDefinition < Rubydex::Definition; end
-class Rubydex::ConstantAliasDefinition < Rubydex::Definition; end
-class Rubydex::ConstantDefinition < Rubydex::Definition; end
+
+class Rubydex::ConstantAliasDefinition < Rubydex::Definition
+  sig { returns(String) }
+  def raw_name; end
+end
+
+class Rubydex::ConstantDefinition < Rubydex::Definition
+  sig { returns(String) }
+  def raw_name; end
+end
+
 class Rubydex::GlobalVariableAliasDefinition < Rubydex::Definition; end
 class Rubydex::GlobalVariableDefinition < Rubydex::Definition; end
 class Rubydex::InstanceVariableDefinition < Rubydex::Definition; end
 
 class Rubydex::MethodAliasDefinition < Rubydex::Definition
+  sig { returns(T::Array[Rubydex::Signature]) }
+  def signatures; end
+
   sig { returns(T.nilable(Rubydex::Method)) }
   def target; end
 end
 
-class Rubydex::MethodDefinition < Rubydex::Definition; end
+class Rubydex::MethodDefinition < Rubydex::Definition
+  sig { returns(T::Array[Rubydex::Signature]) }
+  def signatures; end
+end
+
+class Rubydex::Signature
+  sig { params(parameters: T::Array[Rubydex::Signature::Parameter]).void }
+  def initialize(parameters); end
+
+  sig { returns(T::Array[Rubydex::Signature::Parameter]) }
+  def parameters; end
+
+  sig do
+    returns([
+      T::Array[Rubydex::Signature::PositionalParameter],
+      T::Array[Rubydex::Signature::OptionalPositionalParameter],
+      T.nilable(Rubydex::Signature::RestPositionalParameter),
+      T::Array[Rubydex::Signature::PostParameter],
+      T::Array[Rubydex::Signature::KeywordParameter],
+      T::Array[Rubydex::Signature::OptionalKeywordParameter],
+      T.nilable(Rubydex::Signature::RestKeywordParameter),
+      T.nilable(Rubydex::Signature::ForwardParameter),
+      T.nilable(Rubydex::Signature::BlockParameter),
+    ])
+  end
+  def deconstruct; end
+
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { returns(T::Array[Rubydex::Signature::PositionalParameter]) }
+  def positional_parameters; end
+
+  sig { returns(T::Array[Rubydex::Signature::OptionalPositionalParameter]) }
+  def optional_positional_parameters; end
+
+  sig { returns(T.nilable(Rubydex::Signature::RestPositionalParameter)) }
+  def rest_positional_parameter; end
+
+  sig { returns(T::Array[Rubydex::Signature::PostParameter]) }
+  def post_parameters; end
+
+  sig { returns(T::Array[Rubydex::Signature::KeywordParameter]) }
+  def keyword_parameters; end
+
+  sig { returns(T::Array[Rubydex::Signature::OptionalKeywordParameter]) }
+  def optional_keyword_parameters; end
+
+  sig { returns(T.nilable(Rubydex::Signature::RestKeywordParameter)) }
+  def rest_keyword_parameter; end
+
+  sig { returns(T.nilable(Rubydex::Signature::ForwardParameter)) }
+  def forward_parameter; end
+
+  sig { returns(T.nilable(Rubydex::Signature::BlockParameter)) }
+  def block_parameter; end
+end
+
+class Rubydex::Signature::Parameter
+  sig { returns(Symbol) }
+  def name; end
+
+  sig { returns(Rubydex::Location) }
+  def location; end
+
+  sig { params(name: Symbol, location: Rubydex::Location).void }
+  def initialize(name, location); end
+end
+
+class Rubydex::Signature::PositionalParameter < Rubydex::Signature::Parameter; end
+class Rubydex::Signature::OptionalPositionalParameter < Rubydex::Signature::Parameter; end
+class Rubydex::Signature::RestPositionalParameter < Rubydex::Signature::Parameter; end
+class Rubydex::Signature::PostParameter < Rubydex::Signature::Parameter; end
+class Rubydex::Signature::KeywordParameter < Rubydex::Signature::Parameter; end
+class Rubydex::Signature::OptionalKeywordParameter < Rubydex::Signature::Parameter; end
+class Rubydex::Signature::RestKeywordParameter < Rubydex::Signature::Parameter; end
+class Rubydex::Signature::ForwardParameter < Rubydex::Signature::Parameter; end
+class Rubydex::Signature::BlockParameter < Rubydex::Signature::Parameter; end
 
 class Rubydex::ModuleDefinition < Rubydex::Definition
   sig { returns(T::Array[Rubydex::Mixin]) }
   def mixins; end
+
+  sig { returns(String) }
+  def raw_name; end
 end
 
 class Rubydex::SingletonClassDefinition < Rubydex::Definition
@@ -204,6 +296,9 @@ class Rubydex::ClassDefinition < Rubydex::Definition
 
   sig { returns(T::Array[Rubydex::Mixin]) }
   def mixins; end
+
+  sig { returns(String) }
+  def raw_name; end
 end
 
 class Rubydex::Mixin
@@ -220,9 +315,64 @@ class Rubydex::Include < Rubydex::Mixin; end
 class Rubydex::Prepend < Rubydex::Mixin; end
 class Rubydex::Extend < Rubydex::Mixin; end
 
+module Rubydex::Severity
+  # Every severity, ordered from the most to the least severe.
+  ALL = T.let(T.unsafe(nil), T::Array[T.class_of(Rubydex::Severity::Base)])
+
+  sig { params(value: Symbol).returns(T.class_of(Rubydex::Severity::Base)) }
+  def self.from_value(value); end
+end
+
+class Rubydex::Severity::Base
+  abstract!
+
+  sig { returns(Symbol) }
+  def self.value; end
+end
+
+class Rubydex::Severity::Error < Rubydex::Severity::Base; end
+class Rubydex::Severity::Warning < Rubydex::Severity::Base; end
+class Rubydex::Severity::Information < Rubydex::Severity::Base; end
+class Rubydex::Severity::Hint < Rubydex::Severity::Base; end
+
+class Rubydex::Rule
+  abstract!
+
+  class << self
+    abstract!
+
+    sig { returns(String) }
+    def rule_name; end
+
+    sig { abstract.returns(T.class_of(Rubydex::Severity::Base)) }
+    def default_severity; end
+
+    sig { params(config: Rubydex::LinterConfig).returns(T.class_of(Rubydex::Severity::Base)) }
+    def severity(config); end
+  end
+end
+
+class Rubydex::RelatedInformation
+  sig { params(message: String, location: Rubydex::Location).void }
+  def initialize(message, location); end
+
+  sig { returns(Rubydex::Location) }
+  def location; end
+
+  sig { returns(String) }
+  def message; end
+end
+
 class Rubydex::Diagnostic
-  sig { params(rule: Symbol, message: String, location: Rubydex::Location).void }
-  def initialize(rule:, message:, location:); end
+  sig do
+    params(
+      rule: T.class_of(Rubydex::Rule),
+      message: String,
+      location: Rubydex::Location,
+      related_information: T::Array[Rubydex::RelatedInformation],
+    ).void
+  end
+  def initialize(rule:, message:, location:, related_information: []); end
 
   sig { returns(Rubydex::Location) }
   def location; end
@@ -230,8 +380,179 @@ class Rubydex::Diagnostic
   sig { returns(String) }
   def message; end
 
-  sig { returns(Symbol) }
+  sig { returns(T.class_of(Rubydex::Rule)) }
   def rule; end
+
+  sig { returns(T::Array[Rubydex::RelatedInformation]) }
+  def related_information; end
+end
+
+module Rubydex::Linter; end
+module Rubydex::Linter::Helpers; end
+module Rubydex::Linter::Rules; end
+
+module Rubydex::Linter::Helpers::PathHelpers
+  extend T::Helpers
+
+  requires_ancestor { Rubydex::Linter::CustomRule }
+
+  EXCLUDE_FNMATCH_FLAGS = T.let(T.unsafe(nil), Integer)
+  TEST_PATHS = T.let(T.unsafe(nil), T::Array[String])
+
+  sig do
+    params(
+      path: String,
+      patterns: T::Array[String],
+      workspace: String,
+      flags: Integer,
+    ).returns(T::Boolean)
+  end
+  def self.path_matches_patterns?(path, patterns, workspace:, flags: 0); end
+
+  sig { params(location: Rubydex::Location, workspace: String).returns(String) }
+  def self.display_path(location, workspace:); end
+
+  sig do
+    params(
+      definitions: T::Enumerable[Rubydex::Definition],
+      excluded_patterns: T::Array[String],
+    ).returns(T::Array[Rubydex::Definition])
+  end
+  def reject_definitions_in_paths(definitions, excluded_patterns); end
+
+  sig do
+    params(
+      definitions: T::Enumerable[Rubydex::Definition],
+      patterns: T::Array[String],
+    ).returns(T::Array[Rubydex::Definition])
+  end
+  def select_definitions_in_paths(definitions, patterns); end
+
+  private
+
+  sig { params(path: String, patterns: T::Array[String]).returns(T::Boolean) }
+  def path_matches_patterns?(path, patterns); end
+
+  sig { params(path: String).returns(T::Boolean) }
+  def test_path?(path); end
+
+  sig { params(definition: Rubydex::Definition).returns(T.nilable(String)) }
+  def path_for_definition(definition); end
+end
+
+module Rubydex::Linter::Helpers::SourceAccessHelpers
+  sig { params(uri: String).returns(Rubydex::Location) }
+  def file_location(uri); end
+
+  sig { params(uri: String).returns(String) }
+  def path_for_uri(uri); end
+
+  private
+
+  sig { params(location: Rubydex::Location).returns(T.nilable(String)) }
+  def source_for_location(location); end
+end
+
+# Base class for semantic lint rules, which collect their diagnostics by walking a resolved graph.
+class Rubydex::Linter::CustomRule < Rubydex::Rule
+  abstract!
+
+  sig { params(graph: Rubydex::Graph, config: Rubydex::LinterConfig).void }
+  def initialize(graph, config:); end
+
+  sig { returns(Rubydex::Graph) }
+  def graph; end
+
+  sig { returns(Rubydex::LinterConfig) }
+  def config; end
+
+  sig { returns(T::Array[Rubydex::Diagnostic]) }
+  def diagnostics; end
+
+  sig { params(definition: Rubydex::Definition).returns(Rubydex::Location) }
+  def diagnostic_location(definition); end
+
+  sig { params(base_name: String).returns(T::Enumerable[Rubydex::Class]) }
+  def child_classes(base_name); end
+
+  sig { params(name: String).returns(Rubydex::Namespace) }
+  def required_namespace(name); end
+
+  sig do
+    params(
+      namespace: Rubydex::Namespace,
+      method_name: String,
+    ).returns(Rubydex::Method)
+  end
+  def required_method(namespace, method_name); end
+
+  sig { returns(String) }
+  def rule_name; end
+
+  sig { abstract.void }
+  def lint; end
+
+  protected
+
+  sig do
+    params(
+      message: String,
+      location: Rubydex::Location,
+      related_information: T::Array[Rubydex::RelatedInformation],
+    ).void
+  end
+  def add_diagnostic(message, location, related_information: []); end
+end
+
+class Rubydex::Linter::MissingGraphDependencyError < StandardError
+  sig { params(rule_name: String, dependency: String).void }
+  def initialize(rule_name, dependency); end
+end
+
+class Rubydex::Linter::RuleLoadError < StandardError; end
+
+class Rubydex::Linter::RuleLoader
+  RULE_GLOB = T.let(T.unsafe(nil), String)
+
+  sig { params(workspace_path: String).void }
+  def self.load(workspace_path); end
+end
+
+class Rubydex::Linter::Rules::RuleStructure < Rubydex::Linter::CustomRule
+  include Rubydex::Linter::Helpers::SourceAccessHelpers
+
+  BASE_RULE_NAME = T.let(T.unsafe(nil), String)
+  RULE_NAMESPACE = T.let(T.unsafe(nil), String)
+  RULE_FILE_PATTERNS = T.let(T.unsafe(nil), T::Array[String])
+  TEST_FILE_PATTERNS = T.let(T.unsafe(nil), T::Array[String])
+
+  class << self
+    sig { override.returns(T.class_of(Rubydex::Severity::Base)) }
+    def default_severity; end
+  end
+
+  sig { override.void }
+  def lint; end
+end
+
+class Rubydex::Linter::Runner
+  sig do
+    params(
+      graph: Rubydex::Graph,
+      custom_rules: T::Array[T.class_of(Rubydex::Linter::CustomRule)],
+      config: Rubydex::LinterConfig,
+    ).void
+  end
+  def initialize(graph, custom_rules:, config:); end
+
+  sig { returns(Rubydex::Graph) }
+  def graph; end
+
+  sig { returns(T::Array[T.class_of(Rubydex::Linter::CustomRule)]) }
+  def custom_rules; end
+
+  sig { returns(T::Array[Rubydex::Diagnostic]) }
+  def run; end
 end
 
 class Rubydex::Keyword
@@ -273,6 +594,74 @@ end
 class Rubydex::Error < StandardError; end
 class Rubydex::AliasCycleError < Rubydex::Error; end
 class Rubydex::ConfigError < Rubydex::Error; end
+class Rubydex::QueryError < Rubydex::Error; end
+class Rubydex::QuerySyntaxError < Rubydex::QueryError; end
+class Rubydex::QueryExecutionError < Rubydex::QueryError; end
+class Rubydex::StaleQueryResultError < Rubydex::QueryError; end
+
+# The configuration of a workspace, parsed from its `rubydex.toml`. It carries both the settings that are global to
+# every built-in tool, such as the workspace being analyzed, and the typed settings of each tool's own section (e.g.
+# `[graph]`, `[linter]`).
+class Rubydex::Config
+  class << self
+    # Loads the configuration file for `workspace_path/rubydex.toml` if it exists or uses the defaults.
+    sig { params(workspace_path: String).returns(Rubydex::Config) }
+    def load(workspace_path); end
+  end
+
+  # The linter's settings, read from the `[linter]` section.
+  sig { returns(Rubydex::LinterConfig) }
+  def linter; end
+
+  # The configured workspace path, which is usually PWD, except for editors that spawn language servers outside of pwd.
+  sig { returns(String) }
+  def workspace_path; end
+end
+
+# The linter's settings, read from the `[linter]` section of the configuration file.
+class Rubydex::LinterConfig
+  # The configured rules, keyed by rule name. Only rules the configuration file mentions appear here, so a rule that
+  # was never configured is absent rather than present with its defaults.
+  sig { returns(T::Hash[String, Rubydex::RuleConfig]) }
+  attr_reader :rules
+
+  sig { params(rules: T::Hash[String, Rubydex::RuleConfig]).void }
+  def initialize(rules); end
+
+  sig { params(rule_class: T.class_of(Rubydex::Rule)).returns(T::Boolean) }
+  def rule_enabled?(rule_class); end
+
+  sig { params(rule_class: T.class_of(Rubydex::Rule)).returns(T::Array[String]) }
+  def excludes_for(rule_class); end
+
+  sig { params(rule_class: T.class_of(Rubydex::Rule)).returns(T.nilable(T.class_of(Rubydex::Severity::Base))) }
+  def severity_for(rule_class); end
+end
+
+# The settings of a single linter rule, read from a `[linter.rules.RuleName]` table.
+class Rubydex::RuleConfig
+  sig { returns(String) }
+  attr_reader :name
+
+  sig { returns(T::Array[String]) }
+  attr_reader :exclude_patterns
+
+  sig { returns(T.nilable(T.class_of(Rubydex::Severity::Base))) }
+  attr_reader :severity
+
+  sig do
+    params(
+      name: String,
+      enabled: T::Boolean,
+      exclude_patterns: T::Array[String],
+      severity: T.nilable(T.class_of(Rubydex::Severity::Base)),
+    ).void
+  end
+  def initialize(name, enabled, exclude_patterns = [], severity = nil); end
+
+  sig { returns(T::Boolean) }
+  def enabled?; end
+end
 
 class Rubydex::Failure
   sig { params(message: String).void }
@@ -293,13 +682,55 @@ class Rubydex::Query
     def schema(format = :table); end
   end
 
-  sig { params(graph: Rubydex::Graph, format: T.any(String, Symbol)).returns(String) }
-  def render(graph, format = :table); end
+  sig { params(graph: Rubydex::Graph).returns(Rubydex::Query::Result) }
+  def run(graph); end
+end
+
+# The columns and rows produced by one run of a query. Enumerable over its rows.
+class Rubydex::Query::Result
+  include Enumerable
+  extend T::Generic
+
+  Elem = type_member { { fixed: T::Hash[String, T.untyped] } }
+
+  class << self
+    private
+
+    # A result only comes from `Query#run`. The C extension undefines `new`, so a call raises.
+    sig { returns(T.noreturn) }
+    def new; end
+  end
+
+  sig { returns(T::Array[String]) }
+  def columns; end
+
+  sig { returns(T::Array[T::Hash[String, T.untyped]]) }
+  def rows; end
+
+  sig { override.params(block: T.proc.params(row: T::Hash[String, T.untyped]).void).returns(T.self_type) }
+  sig { override.returns(T::Enumerator[T::Hash[String, T.untyped]]) }
+  def each(&block); end
+
+  sig { returns(Integer) }
+  def size; end
+
+  sig { returns(Integer) }
+  def length; end
+
+  sig { returns(T::Boolean) }
+  def empty?; end
+
+  sig { params(format: T.any(String, Symbol)).returns(String) }
+  def render(format = :table); end
 end
 
 class Rubydex::Graph
-  sig { params(workspace_path: T.nilable(String)).void }
-  def initialize(workspace_path: nil); end
+  class << self
+    # Creates a new graph with the loaded configuration. For use cases where the graph must be shared between
+    # different tools, do not use this. Create and own a `Config` object instead.
+    sig { params(workspace_path: String).returns(T.attached_class) }
+    def configure_for_workspace(workspace_path); end
+  end
 
   sig { params(fully_qualified_name: String).returns(T.nilable(Rubydex::Declaration)) }
   def [](fully_qualified_name); end
@@ -332,12 +763,13 @@ class Rubydex::Graph
   sig { returns(T::Array[String]) }
   def index_workspace; end
 
-  # Loads configuration, merging its exclusion patterns into the graph's configuration (the workspace path is never
-  # overridden). With `config_path` (resolved relative to the workspace path), an explicitly named file that does not
-  # exist raises `Rubydex::ConfigError`. With no argument, the default `.rubydex` is loaded if present and ignored if
-  # missing. Raises `Rubydex::ConfigError` if a file cannot be read or is malformed.
-  sig { params(config_path: T.nilable(String)).void }
-  def load_config(config_path = nil); end
+  # Returns the keyword object for the name, or `nil` if it is not a Ruby keyword
+  sig { params(name: String).returns(T.nilable(Rubydex::Keyword)) }
+  def keyword(name); end
+
+  # Loads the configuration in the graph.
+  sig { params(config: Rubydex::Config).void }
+  def load_config(config); end
 
   sig { returns(T::Enumerable[Rubydex::MethodReference]) }
   def method_references; end
@@ -348,8 +780,18 @@ class Rubydex::Graph
   sig { returns(T.self_type) }
   def resolve; end
 
-  sig { params(name: String, nesting: T::Array[String]).returns(T.nilable(Rubydex::Declaration)) }
-  def resolve_constant(name, nesting); end
+  sig do
+    params(
+      name: String,
+      context: T.any(
+        T::Array[String],
+        Rubydex::ClassDefinition,
+        Rubydex::SingletonClassDefinition,
+        Rubydex::ModuleDefinition,
+      ),
+    ).returns(T.nilable(Rubydex::Declaration))
+  end
+  def resolve_constant(name, context); end
 
   sig { params(require_path: String, load_paths: T::Array[String]).returns(T.nilable(Rubydex::Document)) }
   def resolve_require_path(require_path, load_paths); end
@@ -360,15 +802,16 @@ class Rubydex::Graph
   sig { params(queries: String).returns(T::Enumerable[Rubydex::Declaration]) }
   def fuzzy_search(*queries); end
 
+  sig { returns(T::Enumerable[Rubydex::Declaration]) }
+  def dead_code_candidates; end
+
   sig { params(encoding: String).void }
   def encoding=(encoding); end
 
+  # The root directory of the workspace being analyzed, which comes from the loaded `Rubydex::Config`
   sig { returns(String) }
   def workspace_path; end
 
-  sig { params(workspace_path: String).returns(String) }
-  def workspace_path=(workspace_path); end
-
   sig { returns(T::Array[String]) }
   def workspace_paths; end
 

data/rust/Cargo.lock

@@ -262,9 +262,9 @@ checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
 name = "cypher-parser"
-version = "0.2.0"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fed0d1e561d51e651bdf70f8439da293fd0f1fe34d8431059061eadaefc7abb1"
+checksum = "6ada60f869dbe5818d0ee40b06ad988627cc0d692d1ed42d692353bf0af8ddb6"
 
 [[package]]
 name = "difflib"

data/rust/rubydex/Cargo.toml

@@ -15,6 +15,10 @@ categories = ["development-tools"]
 name = "rubydex_cli"
 path = "src/main.rs"
 
+[[bin]]
+name = "generate_ruby_rules"
+path = "src/bin/generate_ruby_rules.rs"
+
 [lib]
 crate-type = ["rlib"]
 
@@ -27,7 +31,7 @@ jemalloc_dylib = ["jemalloc", "tikv-jemallocator/disable_initial_exec_tls"]
 test_utils = ["dep:tempfile"]
 
 [dependencies]
-cypher-parser = "0.2"
+cypher-parser = "0.8.1"
 ruby-prism = "1.9.0"
 ruby-rbs = "0.3"
 url = "2.5.4"

data/rust/rubydex/benches/graph_memory.rs

@@ -3,6 +3,7 @@ mod imp {
     use std::time::Instant;
 
     use rubydex::{
+        config::Config,
         indexing::{self, IndexerBackend},
         listing,
         model::graph::Graph,
@@ -27,11 +28,8 @@ mod imp {
         assert!(workspace_path.is_dir(), "the workspace path must be a directory");
 
         let mut graph = Graph::new();
-        graph.set_workspace_path(workspace_path);
-
-        if let Err(error) = graph.load_config(None) {
-            eprintln!("{error}");
-        }
+        let config = Config::load(&workspace_path).expect("the workspace configuration must be valid");
+        graph.load_config(&config);
 
         let time = Instant::now();