rubydex 0.2.9 → 0.4.0

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

@@ -1,4 +1,5 @@
 use super::normalize_indentation;
+use crate::path_helpers;
 use std::fs;
 use std::path::{Path, PathBuf};
 use tempfile::TempDir;
@@ -37,7 +38,7 @@ impl Context {
     #[must_use]
     pub fn new() -> Self {
         let root = tempfile::tempdir().expect("failed to create temp dir");
-        let absolute_path = fs::canonicalize(root.path()).unwrap();
+        let absolute_path = path_helpers::resolved(root.path()).unwrap();
         Self {
             _root: root,
             absolute_path,

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

@@ -540,18 +540,13 @@ macro_rules! assert_descendants {
             .declarations()
             .get(&$crate::model::ids::DeclarationId::from($parent))
             .unwrap();
-        let actual = match parent {
-            $crate::model::declaration::Declaration::Namespace($crate::model::declaration::Namespace::Class(class)) => {
-                class.descendants().iter().cloned().collect::<Vec<_>>()
-            }
-            $crate::model::declaration::Declaration::Namespace($crate::model::declaration::Namespace::Module(
-                module,
-            )) => module.descendants().iter().cloned().collect::<Vec<_>>(),
-            $crate::model::declaration::Declaration::Namespace(
-                $crate::model::declaration::Namespace::SingletonClass(singleton),
-            ) => singleton.descendants().iter().cloned().collect::<Vec<_>>(),
-            _ => panic!("Tried to get descendants for a declaration that isn't a namespace"),
-        };
+        let actual = parent
+            .as_namespace()
+            .expect("Tried to get descendants for a declaration that isn't a namespace")
+            .descendants()
+            .iter()
+            .cloned()
+            .collect::<Vec<_>>();
 
         for descendant in &$descendants {
             let descendant_id = $crate::model::ids::DeclarationId::from(*descendant);
@@ -667,6 +662,25 @@ macro_rules! assert_instance_variables_eq {
 #[cfg(test)]
 #[macro_export]
 macro_rules! assert_diagnostics_eq {
+    ($context:expr, $expected_diagnostics:expr, severity: $expected_severity:expr) => {{
+        let context = &$context;
+        $crate::assert_diagnostics_eq!(context, $expected_diagnostics);
+
+        let expected_severity = $expected_severity;
+        let actual_severities = context
+            .graph()
+            .all_diagnostics()
+            .iter()
+            .map(|diagnostic| diagnostic.rule().default_severity())
+            .collect::<Vec<_>>();
+        assert_eq!(
+            vec![expected_severity; actual_severities.len()],
+            actual_severities,
+            "diagnostic severities mismatch: expected all `{:?}`, got `{:?}`",
+            expected_severity,
+            actual_severities
+        );
+    }};
     ($context:expr, $expected_diagnostics:expr) => {{
         assert_eq!($expected_diagnostics, $context.format_diagnostics(&[]).as_slice());
     }};

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

@@ -557,6 +557,25 @@ macro_rules! assert_method_has_receiver {
 #[cfg(test)]
 #[macro_export]
 macro_rules! assert_local_diagnostics_eq {
+    ($context:expr, $expected_diagnostics:expr, severity: $expected_severity:expr) => {{
+        let context = &$context;
+        $crate::assert_local_diagnostics_eq!(context, $expected_diagnostics);
+
+        let expected_severity = $expected_severity;
+        let actual_severities = context
+            .graph()
+            .diagnostics()
+            .iter()
+            .map(|diagnostic| diagnostic.rule().default_severity())
+            .collect::<Vec<_>>();
+        assert_eq!(
+            vec![expected_severity; actual_severities.len()],
+            actual_severities,
+            "diagnostic severities mismatch: expected all `{:?}`, got `{:?}`",
+            expected_severity,
+            actual_severities
+        );
+    }};
     ($context:expr, $expected_diagnostics:expr) => {{
         let mut diagnostics = $context.graph().diagnostics().iter().collect::<Vec<_>>();
         diagnostics.sort_by_key(|d| d.offset());

data/rust/rubydex/tests/cli.rs

@@ -60,7 +60,7 @@ fn single_directory_argument_is_workspace_root_for_config() {
     with_context(|context| {
         context.write("included.rb", "class Included\nend\n");
         context.write("excluded/skipped.rb", "class Skipped\nend\n");
-        context.write("rubydex.toml", "exclude = [\"excluded\"]\n");
+        context.write("rubydex.toml", "[graph]\nexclude = [\"excluded\"]\n");
 
         rdx(&[context.absolute_path().to_str().unwrap()])
             .success()
@@ -74,7 +74,7 @@ fn first_directory_argument_is_workspace_root_for_config() {
     with_context(|context| {
         context.write("included/kept.rb", "class Included\nend\n");
         context.write("excluded/skipped.rb", "class Skipped\nend\n");
-        context.write("rubydex.toml", "exclude = [\"excluded\"]\n");
+        context.write("rubydex.toml", "[graph]\nexclude = [\"excluded\"]\n");
 
         rdx(&[
             context.absolute_path().to_str().unwrap(),
@@ -92,7 +92,7 @@ fn single_file_argument_is_not_used_as_workspace_root() {
     with_context(|context| {
         context.write("included.rb", "class Included\nend\n");
         context.write("excluded/skipped.rb", "class Skipped\nend\n");
-        context.write("rubydex.toml", "exclude = [\"excluded\"]\n");
+        context.write("rubydex.toml", "[graph]\nexclude = [\"excluded\"]\n");
 
         rdx(&[context.absolute_path_to("excluded/skipped.rb").to_str().unwrap()])
             .success()
@@ -106,7 +106,7 @@ fn first_file_argument_is_not_used_as_workspace_root() {
     with_context(|context| {
         context.write("included.rb", "class Included\nend\n");
         context.write("excluded/skipped.rb", "class Skipped\nend\n");
-        context.write("rubydex.toml", "exclude = [\"excluded\"]\n");
+        context.write("rubydex.toml", "[graph]\nexclude = [\"excluded\"]\n");
 
         rdx(&[
             context.absolute_path_to("included.rb").to_str().unwrap(),

data/rust/rubydex-sys/src/config_api.rs

@@ -0,0 +1,205 @@
+use crate::diagnostic_api::DiagnosticSeverity;
+use crate::utils;
+use libc::{c_char, c_void};
+use rubydex::config::{Config, Rule};
+use rubydex::errors::Errors;
+use std::ffi::CString;
+use std::path::Path;
+use std::ptr;
+
+/// An opaque pointer to a loaded configuration
+pub type ConfigPointer = *mut c_void;
+
+/// The result of loading a configuration file, carrying either a parsed configuration or an error message.
+#[repr(C)]
+pub struct CConfigResult {
+    /// Non-null on success: a heap-allocated parsed configuration. Free with `rdx_config_free`.
+    pub config: ConfigPointer,
+    /// Non-null on error; null on success. Caller must free with `free_c_string`.
+    pub error: *const c_char,
+}
+
+impl CConfigResult {
+    fn success(config: Config) -> Self {
+        Self {
+            config: Box::into_raw(Box::new(config)).cast::<c_void>(),
+            error: ptr::null(),
+        }
+    }
+
+    fn error(message: &str) -> Self {
+        // Parse errors quote raw file content, which may contain NUL bytes that a C string cannot carry.
+        let message = message.replace('\0', "\u{FFFD}");
+
+        Self {
+            config: ptr::null_mut(),
+            error: utils::cstring_raw(&message),
+        }
+    }
+}
+
+/// Loads the configuration of the workspace rooted at `workspace_path`, which is where its `rubydex.toml` is expected
+/// to be. A workspace without a configuration file produces an empty configuration.
+///
+/// # Safety
+///
+/// - `workspace_path` must be a valid, null-terminated string.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_config_load(workspace_path: *const c_char) -> CConfigResult {
+    if workspace_path.is_null() {
+        return CConfigResult::error("workspace path is required");
+    }
+
+    let Ok(workspace_path) = (unsafe { utils::convert_char_ptr_to_string(workspace_path) }) else {
+        return CConfigResult::error("workspace path is not valid UTF-8");
+    };
+
+    match Config::load(Path::new(&workspace_path)) {
+        Ok(config) => CConfigResult::success(config),
+        Err(Errors::ConfigError(message) | Errors::FileError(message)) => CConfigResult::error(&message),
+    }
+}
+
+/// Returns the root directory of the workspace the configuration was loaded for, as a C string. Caller must free with
+/// `free_c_string`.
+///
+/// # Safety
+///
+/// - `config` must be a valid `ConfigPointer` previously returned by `rdx_config_load`.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_config_workspace_path(config: ConfigPointer) -> *const c_char {
+    let config = unsafe { &*config.cast::<Config>() };
+
+    CString::new(utils::interop_path(config.workspace_path()))
+        .map_or(ptr::null(), |c_string| c_string.into_raw().cast_const())
+}
+
+/// Frees a configuration through its pointer. Does nothing when given NULL.
+///
+/// # Safety
+///
+/// - `config` must either be NULL or a valid `ConfigPointer` previously returned by `rdx_config_load` and must not
+///   be used afterwards. Any string pointer borrowed from it becomes invalid.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_config_free(config: ConfigPointer) {
+    if config.is_null() {
+        return;
+    }
+
+    unsafe {
+        let _ = Box::from_raw(config.cast::<Config>());
+    }
+}
+
+/// Borrowed string bytes exposed while building Ruby configuration values.
+#[repr(C)]
+#[derive(Debug)]
+pub struct CConfigString {
+    pub data: *const c_char,
+    pub length: usize,
+}
+
+/// C-compatible struct representing a single configured linter rule.
+#[repr(C)]
+#[derive(Debug)]
+pub struct CLinterRule {
+    pub name: *const c_char,
+    pub name_length: usize,
+    pub enabled: bool,
+    pub exclude_patterns: *const CConfigString,
+    pub exclude_patterns_length: usize,
+    pub severity: *const DiagnosticSeverity,
+}
+
+impl From<&Rule> for CLinterRule {
+    fn from(rule: &Rule) -> Self {
+        let exclude_patterns = rule
+            .exclude_patterns()
+            .iter()
+            .map(|pattern| CConfigString {
+                data: pattern.as_ptr().cast::<c_char>(),
+                length: pattern.len(),
+            })
+            .collect::<Box<[CConfigString]>>();
+        let exclude_patterns_length = exclude_patterns.len();
+        let exclude_patterns = if exclude_patterns.is_empty() {
+            ptr::null()
+        } else {
+            Box::into_raw(exclude_patterns).cast::<CConfigString>().cast_const()
+        };
+        let severity = rule.severity().map_or(ptr::null(), |severity| {
+            Box::into_raw(Box::new(DiagnosticSeverity::from(*severity))).cast_const()
+        });
+
+        Self {
+            name: rule.name().as_ptr().cast::<c_char>(),
+            name_length: rule.name().len(),
+            enabled: rule.enabled(),
+            exclude_patterns,
+            exclude_patterns_length,
+            severity,
+        }
+    }
+}
+
+/// C-compatible array of configured linter rules.
+#[repr(C)]
+pub struct CLinterRuleArray {
+    pub items: *mut CLinterRule,
+    pub len: usize,
+}
+
+/// Returns the configured linter rules as an array. Caller must free it with `rdx_config_linter_rules_free`, while the
+/// configuration is still alive, since the rule names are borrowed from it.
+///
+/// # Safety
+///
+/// - `config` must be a valid `ConfigPointer` previously returned by `rdx_config_load`.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_config_linter_rules(config: ConfigPointer) -> CLinterRuleArray {
+    let config = unsafe { &*config.cast::<Config>() };
+    let rules = config.linter().rules();
+
+    if rules.is_empty() {
+        return CLinterRuleArray {
+            items: ptr::null_mut(),
+            len: 0,
+        };
+    }
+
+    let items = rules.iter().map(CLinterRule::from).collect::<Box<[CLinterRule]>>();
+
+    CLinterRuleArray {
+        len: items.len(),
+        items: Box::into_raw(items).cast::<CLinterRule>(),
+    }
+}
+
+/// Frees an array previously returned by `rdx_config_linter_rules`. The rule names it borrowed are left alone, since
+/// they belong to the configuration.
+///
+/// # Safety
+///
+/// - `rules` must have been returned by `rdx_config_linter_rules` and must not be used afterwards.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_config_linter_rules_free(rules: CLinterRuleArray) {
+    if rules.items.is_null() {
+        return;
+    }
+
+    unsafe {
+        let rules = Box::from_raw(ptr::slice_from_raw_parts_mut(rules.items, rules.len));
+
+        for rule in &*rules {
+            if !rule.exclude_patterns.is_null() {
+                let exclude_patterns =
+                    ptr::slice_from_raw_parts_mut(rule.exclude_patterns.cast_mut(), rule.exclude_patterns_length);
+                let _ = Box::from_raw(exclude_patterns);
+            }
+
+            if !rule.severity.is_null() {
+                let _ = Box::from_raw(rule.severity.cast_mut());
+            }
+        }
+    }
+}