rubydex 0.3.0 → 0.4.0

data/rust/rubydex/src/indexing/ruby_indexer_tests.rs

@@ -6,6 +6,7 @@ use crate::{
     assert_def_comments_eq, assert_def_mixins_eq, assert_def_name_eq, assert_def_name_offset_eq, assert_def_str_eq,
     assert_def_superclass_ref_eq, assert_definition_at, assert_dependents, assert_local_diagnostics_eq,
     assert_method_has_receiver, assert_name_path_eq, assert_no_local_diagnostics, assert_string_eq,
+    diagnostic::Severity,
     model::{
         definitions::{Definition, Parameter, Receiver, Signatures},
         ids::{StringId, UriId},
@@ -967,7 +968,8 @@ mod class_and_module_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            ["dynamic-constant-reference: Dynamic constant reference (1:7-1:10)"]
+            ["DynamicConstantReference: Dynamic constant reference (1:7-1:10)"],
+            severity: Severity::Information
         );
         assert!(context.graph().definitions().is_empty());
     }
@@ -1071,7 +1073,7 @@ mod class_and_module_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            ["dynamic-constant-reference: Dynamic constant reference (1:8-1:11)"]
+            ["DynamicConstantReference: Dynamic constant reference (1:8-1:11)"]
         );
         assert!(context.graph().definitions().is_empty());
     }
@@ -1173,7 +1175,7 @@ mod method_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            ["dynamic-singleton-definition: Dynamic receiver for singleton method definition (1:1-1:17)"]
+            ["DynamicSingletonDefinition: Dynamic receiver for singleton method definition (1:1-1:17)"]
         );
         assert_eq!(context.graph().definitions().len(), 0);
         assert_method_references_eq!(&context, ["foo"]);
@@ -1416,7 +1418,7 @@ mod singleton_class_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            ["dynamic-singleton-definition: Dynamic singleton class definition (1:1-3:4)"]
+            ["DynamicSingletonDefinition: Dynamic singleton class definition (1:1-3:4)"]
         );
         assert_eq!(context.graph().definitions().len(), 0);
     }
@@ -1557,6 +1559,34 @@ mod visibility_tests {
         });
     }
 
+    #[test]
+    fn index_module_function_with_body() {
+        let context = index_source({
+            "
+            module Foo
+              module_function
+
+              def bar
+                @value = CONST
+                baz(1)
+              end
+            end
+            "
+        });
+
+        assert_no_local_diagnostics!(&context);
+        assert_eq!(context.graph().definitions().len(), 4);
+        assert_eq!(context.graph().document().definitions().len(), 4);
+        assert_eq!(context.graph().document().constant_references().len(), 1);
+        assert_eq!(context.graph().document().method_references().len(), 1);
+        assert_constant_references_eq!(&context, ["CONST"]);
+        assert_method_references_eq!(&context, ["baz"]);
+
+        let methods = context.all_definitions_at("4:3-7:6");
+        assert_eq!(methods.len(), 2);
+        assert_definition_at!(&context, "5:5-5:11", InstanceVariable);
+    }
+
     #[test]
     fn index_def_node_with_visibility_nested() {
         let context = index_source({
@@ -1772,12 +1802,13 @@ mod visibility_tests {
         assert_local_diagnostics_eq!(
             &context,
             vec![
-                "invalid-constant-visibility: `private_constant` called at top level (1:1-1:22)",
-                "invalid-constant-visibility: `private_constant` called at top level (2:1-2:27)",
-                "invalid-constant-visibility: Dynamic receiver for `private_constant` (3:1-3:4)",
-                "invalid-constant-visibility: `private_constant` called with a non-literal argument (6:20-6:29)",
-                "invalid-constant-visibility: `private_constant` called with a non-literal argument (6:31-6:42)",
-            ]
+                "InvalidConstantVisibility: `private_constant` called at top level (1:1-1:22)",
+                "InvalidConstantVisibility: `private_constant` called at top level (2:1-2:27)",
+                "InvalidConstantVisibility: Dynamic receiver for `private_constant` (3:1-3:4)",
+                "InvalidConstantVisibility: `private_constant` called with a non-literal argument (6:20-6:29)",
+                "InvalidConstantVisibility: `private_constant` called with a non-literal argument (6:31-6:42)",
+            ],
+            severity: Severity::Warning
         );
 
         assert_eq!(context.graph().definitions().len(), 3); // Foo, Foo.qux, Foo#foo
@@ -1809,11 +1840,11 @@ mod visibility_tests {
         assert_local_diagnostics_eq!(
             &context,
             vec![
-                "invalid-constant-visibility: `public_constant` called at top level (1:1-1:21)",
-                "invalid-constant-visibility: `public_constant` called at top level (2:1-2:26)",
-                "invalid-constant-visibility: Dynamic receiver for `public_constant` (3:1-3:4)",
-                "invalid-constant-visibility: `public_constant` called with a non-literal argument (6:19-6:28)",
-                "invalid-constant-visibility: `public_constant` called with a non-literal argument (6:30-6:41)",
+                "InvalidConstantVisibility: `public_constant` called at top level (1:1-1:21)",
+                "InvalidConstantVisibility: `public_constant` called at top level (2:1-2:26)",
+                "InvalidConstantVisibility: Dynamic receiver for `public_constant` (3:1-3:4)",
+                "InvalidConstantVisibility: `public_constant` called with a non-literal argument (6:19-6:28)",
+                "InvalidConstantVisibility: `public_constant` called with a non-literal argument (6:30-6:41)",
             ]
         );
 
@@ -1890,7 +1921,7 @@ mod visibility_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            vec!["invalid-method-visibility: `private` called with a non-literal argument (4:17-4:27)"]
+            vec!["InvalidMethodVisibility: `private` called with a non-literal argument (4:17-4:27)"]
         );
 
         // :foo is a literal arg, so visibility is still applied
@@ -1916,7 +1947,7 @@ mod visibility_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            vec!["invalid-method-visibility: `private` cannot be called with an explicit receiver (4:3-4:19)"]
+            vec!["InvalidMethodVisibility: `private` cannot be called with an explicit receiver (4:3-4:19)"]
         );
 
         for def in context.graph().definitions().values() {
@@ -1941,7 +1972,7 @@ mod visibility_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            vec!["invalid-method-visibility: `private` called with a non-literal argument (4:11-4:21)"]
+            vec!["InvalidMethodVisibility: `private` called with a non-literal argument (4:11-4:21)"]
         );
 
         // No MethodVisibilityDefinition created
@@ -1965,7 +1996,7 @@ mod visibility_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            vec!["invalid-method-visibility: `private` called with a non-literal argument (2:11-2:23)"]
+            vec!["InvalidMethodVisibility: `private` called with a non-literal argument (2:11-2:23)"]
         );
 
         // No MethodVisibilityDefinition created
@@ -1989,7 +2020,7 @@ mod visibility_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            vec!["invalid-method-visibility: `private` called with a non-literal argument (2:11-2:35)"]
+            vec!["InvalidMethodVisibility: `private` called with a non-literal argument (2:11-2:35)"]
         );
 
         // No MethodVisibilityDefinition or AttrReader created from that call
@@ -2032,9 +2063,7 @@ mod visibility_tests {
         // attr_reader(:foo) returns an array in multi-arg context, invalid for `private`
         assert_local_diagnostics_eq!(
             &context,
-            vec![
-                "invalid-method-visibility: `private` with `attr_*` is only supported as a single argument (2:11-2:28)"
-            ]
+            vec!["InvalidMethodVisibility: `private` with `attr_*` is only supported as a single argument (2:11-2:28)"]
         );
 
         // foo reader still defined via side effects, but public
@@ -2097,7 +2126,7 @@ mod visibility_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            vec!["invalid-method-visibility: `module_function` can only be used in modules (4:3-4:23)"]
+            vec!["InvalidMethodVisibility: `module_function` can only be used in modules (4:3-4:23)"]
         );
 
         for def in context.graph().definitions().values() {
@@ -2169,8 +2198,8 @@ mod visibility_tests {
         assert_local_diagnostics_eq!(
             &context,
             vec![
-                "invalid-method-visibility: `private` called with a non-literal argument (2:25-2:32)",
-                "invalid-method-visibility: `private` called with a non-literal argument (3:11-3:18)",
+                "InvalidMethodVisibility: `private` called with a non-literal argument (2:25-2:32)",
+                "InvalidMethodVisibility: `private` called with a non-literal argument (3:11-3:18)",
             ]
         );
 
@@ -2200,8 +2229,8 @@ mod visibility_tests {
         assert_local_diagnostics_eq!(
             &context,
             vec![
-                "invalid-method-visibility: `private` called with a non-literal argument (2:11-2:18)",
-                "invalid-method-visibility: `private` called with a non-literal argument (2:20-2:27)",
+                "InvalidMethodVisibility: `private` called with a non-literal argument (2:11-2:18)",
+                "InvalidMethodVisibility: `private` called with a non-literal argument (2:20-2:27)",
             ]
         );
 
@@ -2221,7 +2250,7 @@ mod visibility_tests {
         // module_function in a class is always invalid regardless of args
         assert_local_diagnostics_eq!(
             &context,
-            vec!["invalid-method-visibility: `module_function` can only be used in modules (2:3-2:37)"]
+            vec!["InvalidMethodVisibility: `module_function` can only be used in modules (2:3-2:37)"]
         );
 
         for def in context.graph().definitions().values() {
@@ -2307,12 +2336,13 @@ mod visibility_tests {
         assert_local_diagnostics_eq!(
             &context,
             vec![
-                "invalid-method-visibility: `private_class_method` called at top level (1:1-1:34)",
-                "invalid-method-visibility: `private_class_method` called at top level (2:1-2:39)",
-                "invalid-method-visibility: `private_class_method` called with a non-literal argument (6:24-6:35)",
-                "invalid-method-visibility: `private_class_method` does not accept `attr_*` arguments (8:24-8:41)",
-                "invalid-method-visibility: `private_class_method` requires a singleton method definition (9:24-9:39)",
-            ]
+                "InvalidMethodVisibility: `private_class_method` called at top level (1:1-1:34)",
+                "InvalidMethodVisibility: `private_class_method` called at top level (2:1-2:39)",
+                "InvalidMethodVisibility: `private_class_method` called with a non-literal argument (6:24-6:35)",
+                "InvalidMethodVisibility: `private_class_method` does not accept `attr_*` arguments (8:24-8:41)",
+                "InvalidMethodVisibility: `private_class_method` requires a singleton method definition (9:24-9:39)",
+            ],
+            severity: Severity::Warning
         );
     }
 
@@ -2346,7 +2376,7 @@ mod visibility_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            vec!["invalid-method-visibility: `private_class_method` called with a non-literal argument (5:28-5:40)"]
+            vec!["InvalidMethodVisibility: `private_class_method` called with a non-literal argument (5:28-5:40)"]
         );
 
         assert_definition_at!(&context, "5:25-5:26", MethodVisibility, |def| {
@@ -2367,7 +2397,7 @@ mod visibility_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            vec!["invalid-method-visibility: `private_class_method` called at top level (1:1-1:32)"]
+            vec!["InvalidMethodVisibility: `private_class_method` called at top level (1:1-1:32)"]
         );
         assert_constant_references_eq!(&context, ["NESTED_REF"]);
     }
@@ -2452,7 +2482,7 @@ mod visibility_tests {
         assert_local_diagnostics_eq!(
             &context,
             vec![
-                "invalid-method-visibility: `private_class_method` array element must be a Symbol, String, or method definition (5:32-5:42)"
+                "InvalidMethodVisibility: `private_class_method` array element must be a Symbol, String, or method definition (5:32-5:42)"
             ]
         );
 
@@ -2480,9 +2510,7 @@ mod visibility_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            vec![
-                "invalid-method-visibility: `private_class_method` requires a singleton method definition (2:25-2:49)"
-            ]
+            vec!["InvalidMethodVisibility: `private_class_method` requires a singleton method definition (2:25-2:49)"]
         );
 
         for def in context.graph().definitions().values() {
@@ -2514,7 +2542,7 @@ mod visibility_tests {
         assert_local_diagnostics_eq!(
             &context,
             vec![
-                "invalid-method-visibility: `private_class_method` array argument must be the only argument (5:24-5:28)"
+                "InvalidMethodVisibility: `private_class_method` array argument must be the only argument (5:24-5:28)"
             ]
         );
 
@@ -2817,8 +2845,8 @@ mod constant_reference_tests {
         assert_local_diagnostics_eq!(
             &context,
             [
-                "dynamic-constant-reference: Dynamic constant reference (3:6-3:14)",
-                "parse-warning: assigned but unused variable - foo (5:1-5:4)",
+                "DynamicConstantReference: Dynamic constant reference (3:6-3:14)",
+                "ParseWarning: assigned but unused variable - foo (5:1-5:4)",
             ]
         );
 
@@ -3001,7 +3029,7 @@ mod method_reference_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            ["parse-error: unexpected ... when the parent method is not forwarding (31:5-31:8)"]
+            ["ParseError: unexpected ... when the parent method is not forwarding (31:5-31:8)"]
         );
 
         assert_method_references_eq!(
@@ -3087,18 +3115,18 @@ mod method_reference_tests {
         assert_local_diagnostics_eq!(
             &context,
             [
-                "parse-warning: possibly useless use of != in void context (1:1-1:7)",
-                "parse-warning: possibly useless use of % in void context (2:1-2:6)",
-                "parse-warning: possibly useless use of & in void context (3:1-3:6)",
-                "parse-warning: possibly useless use of * in void context (5:1-5:6)",
-                "parse-warning: possibly useless use of ** in void context (6:1-6:7)",
-                "parse-warning: possibly useless use of + in void context (7:1-7:6)",
-                "parse-warning: possibly useless use of - in void context (8:1-8:6)",
-                "parse-warning: possibly useless use of / in void context (9:1-9:6)",
-                "parse-warning: possibly useless use of == in void context (11:1-11:7)",
-                "parse-warning: possibly useless use of ^ in void context (14:1-14:6)",
-                "parse-warning: possibly useless use of | in void context (15:1-15:6)",
-                "parse-warning: possibly useless use of <=> in void context (17:1-17:8)"
+                "ParseWarning: possibly useless use of != in void context (1:1-1:7)",
+                "ParseWarning: possibly useless use of % in void context (2:1-2:6)",
+                "ParseWarning: possibly useless use of & in void context (3:1-3:6)",
+                "ParseWarning: possibly useless use of * in void context (5:1-5:6)",
+                "ParseWarning: possibly useless use of ** in void context (6:1-6:7)",
+                "ParseWarning: possibly useless use of + in void context (7:1-7:6)",
+                "ParseWarning: possibly useless use of - in void context (8:1-8:6)",
+                "ParseWarning: possibly useless use of / in void context (9:1-9:6)",
+                "ParseWarning: possibly useless use of == in void context (11:1-11:7)",
+                "ParseWarning: possibly useless use of ^ in void context (14:1-14:6)",
+                "ParseWarning: possibly useless use of | in void context (15:1-15:6)",
+                "ParseWarning: possibly useless use of <=> in void context (17:1-17:8)"
             ]
         );
 
@@ -3120,7 +3148,7 @@ mod method_reference_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            ["parse-warning: possibly useless use of < in void context (1:1-1:6)"]
+            ["ParseWarning: possibly useless use of < in void context (1:1-1:6)"]
         );
 
         assert_method_references_eq!(&context, ["x", "<", "<=>", "y"]);
@@ -3136,7 +3164,7 @@ mod method_reference_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            ["parse-warning: possibly useless use of <= in void context (1:1-1:7)"]
+            ["ParseWarning: possibly useless use of <= in void context (1:1-1:7)"]
         );
 
         assert_method_references_eq!(&context, ["x", "<=", "<=>", "y"]);
@@ -3152,7 +3180,7 @@ mod method_reference_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            ["parse-warning: possibly useless use of > in void context (1:1-1:6)"]
+            ["ParseWarning: possibly useless use of > in void context (1:1-1:6)"]
         );
 
         assert_method_references_eq!(&context, ["x", "<=>", ">", "y"]);
@@ -3168,7 +3196,7 @@ mod method_reference_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            ["parse-warning: possibly useless use of >= in void context (1:1-1:7)"]
+            ["ParseWarning: possibly useless use of >= in void context (1:1-1:7)"]
         );
 
         assert_method_references_eq!(&context, ["x", "<=>", ">=", "y"]);
@@ -3672,10 +3700,10 @@ mod superclass_tests {
         assert_local_diagnostics_eq!(
             &context,
             [
-                "dynamic-ancestor: Dynamic superclass (1:13-1:24)",
-                "dynamic-ancestor: Dynamic superclass (2:13-2:16)",
-                "dynamic-constant-reference: Dynamic constant reference (4:13-4:16)",
-                "dynamic-ancestor: Dynamic superclass (4:13-4:21)",
+                "DynamicAncestor: Dynamic superclass (1:13-1:24)",
+                "DynamicAncestor: Dynamic superclass (2:13-2:16)",
+                "DynamicConstantReference: Dynamic constant reference (4:13-4:16)",
+                "DynamicAncestor: Dynamic superclass (4:13-4:21)",
             ]
         );
 
@@ -3858,15 +3886,15 @@ mod mixin_tests {
         assert_local_diagnostics_eq!(
             &context,
             [
-                "dynamic-constant-reference: Dynamic constant reference (1:9-1:12)",
-                "dynamic-ancestor: Dynamic mixin argument (1:9-1:17)",
-                "dynamic-constant-reference: Dynamic constant reference (2:9-2:12)",
-                "dynamic-ancestor: Dynamic mixin argument (2:9-2:17)",
-                "dynamic-constant-reference: Dynamic constant reference (3:8-3:11)",
-                "dynamic-ancestor: Dynamic mixin argument (3:8-3:16)",
-                "dynamic-ancestor: Dynamic mixin argument (5:9-5:12)",
-                "dynamic-ancestor: Dynamic mixin argument (6:9-6:12)",
-                "dynamic-ancestor: Dynamic mixin argument (7:8-7:11)"
+                "DynamicConstantReference: Dynamic constant reference (1:9-1:12)",
+                "DynamicAncestor: Dynamic mixin argument (1:9-1:17)",
+                "DynamicConstantReference: Dynamic constant reference (2:9-2:12)",
+                "DynamicAncestor: Dynamic mixin argument (2:9-2:17)",
+                "DynamicConstantReference: Dynamic constant reference (3:8-3:11)",
+                "DynamicAncestor: Dynamic mixin argument (3:8-3:16)",
+                "DynamicAncestor: Dynamic mixin argument (5:9-5:12)",
+                "DynamicAncestor: Dynamic mixin argument (6:9-6:12)",
+                "DynamicAncestor: Dynamic mixin argument (7:8-7:11)"
             ]
         );
         assert!(context.graph().definitions().is_empty());
@@ -3885,9 +3913,9 @@ mod mixin_tests {
         assert_local_diagnostics_eq!(
             &context,
             [
-                "top-level-mixin-self: Top level mixin self (1:9-1:13)",
-                "top-level-mixin-self: Top level mixin self (2:9-2:13)",
-                "top-level-mixin-self: Top level mixin self (3:8-3:12)"
+                "TopLevelMixinSelf: Top level mixin self (1:9-1:13)",
+                "TopLevelMixinSelf: Top level mixin self (2:9-2:13)",
+                "TopLevelMixinSelf: Top level mixin self (3:8-3:12)"
             ]
         );
 
@@ -5168,6 +5196,29 @@ mod dynamic_namespace_tests {
         });
     }
 
+    #[test]
+    fn index_extend_self_in_anonymous_module() {
+        let context = index_source({
+            "
+            Module.new do
+              extend self
+            end
+            "
+        });
+        assert_no_local_diagnostics!(&context);
+
+        assert_definition_at!(&context, "1:1-3:4", Module, |anonymous_module| {
+            let extend = anonymous_module.mixins().first().unwrap();
+            let constant_reference = context
+                .graph()
+                .constant_references()
+                .get(extend.constant_reference_id())
+                .unwrap();
+
+            assert_eq!(anonymous_module.name_id(), constant_reference.name_id());
+        });
+    }
+
     #[test]
     fn index_singleton_method_in_class_new() {
         let context = index_source({
@@ -5261,9 +5312,10 @@ mod diagnostic_tests {
         assert_local_diagnostics_eq!(
             &context,
             [
-                "parse-error: expected an `end` to close the `class` statement (1:1-1:6)",
-                "parse-error: unexpected end-of-input, assuming it is closing the parent top level context (1:10-2:1)"
-            ]
+                "ParseError: expected an `end` to close the `class` statement (1:1-1:6)",
+                "ParseError: unexpected end-of-input, assuming it is closing the parent top level context (1:10-2:1)"
+            ],
+            severity: Severity::Error
         );
 
         // We still index the definition, even though it has errors
@@ -5283,7 +5335,8 @@ mod diagnostic_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            ["parse-warning: assigned but unused variable - foo (1:1-1:4)"]
+            ["ParseWarning: assigned but unused variable - foo (1:1-1:4)"],
+            severity: Severity::Warning
         );
     }
 }

data/rust/rubydex/src/lib.rs

@@ -16,6 +16,7 @@ pub mod listing;
 pub mod model;
 pub mod offset;
 pub mod operation;
+pub(crate) mod path_helpers;
 pub mod position;
 pub mod query;
 pub mod resolution;

data/rust/rubydex/src/listing.rs

@@ -1,6 +1,7 @@
 use crate::{
     errors::Errors,
     job_queue::{Job, JobQueue},
+    path_helpers,
 };
 use crossbeam_channel::{Sender, unbounded};
 use glob::Pattern;
@@ -129,7 +130,7 @@ pub fn collect_file_paths<S: BuildHasher>(
         Arc::new(excluded.iter().filter_map(|entry| Pattern::new(entry).ok()).collect());
 
     for path in paths {
-        let Ok(path) = std::path::absolute(&path) else {
+        let Ok(path) = std::path::absolute(&path).map(path_helpers::simplified) else {
             errors_tx
                 .send(Errors::FileError(format!("Failed to resolve path `{path}`")))
                 .expect("errors receiver dropped before run completion");
@@ -420,6 +421,30 @@ mod tests {
         assert_eq!(files, [foo.to_str().unwrap().to_string()]);
     }
 
+    #[cfg(windows)]
+    #[test]
+    fn collect_files_excludes_a_directory_below_a_verbatim_root() {
+        // Exclusions are joined onto the workspace path the configuration resolved, which is spelled plainly. A root
+        // given verbatim only matches them once it is spelled that way too.
+        let context = Context::new();
+        context.touch(&PathBuf::from("excluded").join("skipped.rb"));
+
+        let mut excluded = HashSet::new();
+        excluded.insert(
+            context
+                .absolute_path_to("excluded")
+                .to_string_lossy()
+                .replace('\\', "/")
+                .into_boxed_str(),
+        );
+
+        let (files, errors) =
+            collect_file_paths(vec![format!(r"\\?\{}", context.absolute_path().display())], &excluded);
+
+        assert!(errors.is_empty());
+        assert!(files.is_empty(), "expected the exclusion to apply: {files:?}");
+    }
+
     #[test]
     fn collect_files_excludes_nested_files_matching_globs() {
         let context = Context::new();

data/rust/rubydex/src/main.rs

@@ -2,6 +2,7 @@ use clap::{Parser, ValueEnum};
 use std::{fs, mem, path::PathBuf};
 
 use rubydex::{
+    config::Config,
     dot,
     indexing::{self, IndexerBackend},
     integrity, listing,
@@ -104,10 +105,12 @@ fn main() {
     let mut graph = Graph::new();
 
     if let Some(workspace_path) = workspace_path_for(&args.paths) {
-        graph.set_workspace_path(workspace_path);
-        if let Err(error) = graph.load_config(None) {
-            eprintln!("{error}");
-            std::process::exit(1);
+        match Config::load(&workspace_path) {
+            Ok(config) => graph.load_config(&config),
+            Err(error) => {
+                eprintln!("{error}");
+                std::process::exit(1);
+            }
         }
     }