feat(gradle): add variable resolution and settings.gradle parsing (#67)

Resolve $var/${var} references in build.gradle/build.gradle.kts from
gradle.properties files (walks parent directories with child-overrides-parent
merge). Parse pluginManagement { plugins { } } blocks in settings.gradle for
plugin dependency tracking with Maven coordinate convention.

Author: bug-ops

CHANGELOG.md

@@ -16,6 +16,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - Parses `[versions]`, `[libraries]` sections with `version.ref` resolution
   - Recognizes all Gradle configurations: implementation, api, compileOnly, runtimeOnly, testImplementation, etc.
   - Feature-gated registration in deps-lsp (`gradle`)
+- **Gradle variable resolution** — `$var` and `${var}` in `build.gradle`/`build.gradle.kts` resolved from `gradle.properties` (walks parent directories)
+- **settings.gradle parsing** — Extract plugin dependencies from `pluginManagement { plugins { } }` blocks (Groovy and Kotlin DSL)
 - **Google Maven repository support** — Android packages (`androidx.*`, `com.google.firebase.*`, `com.google.android.*`, `com.android.*`) now resolve from Google Maven instead of Maven Central
 
 ### Changed

Cargo.lock

@@ -165,7 +165,13 @@ impl Ecosystem for GradleEcosystem {
     }
 
     fn manifest_filenames(&self) -> &[&'static str] {
-        &["libs.versions.toml", "build.gradle.kts", "build.gradle"]
+        &[
+            "libs.versions.toml",
+            "build.gradle.kts",
+            "build.gradle",
+            "settings.gradle.kts",
+            "settings.gradle",
+        ]
     }
 
     fn lockfile_filenames(&self) -> &[&'static str] {
@@ -312,6 +318,8 @@ mod tests {
         assert!(eco.manifest_filenames().contains(&"libs.versions.toml"));
         assert!(eco.manifest_filenames().contains(&"build.gradle.kts"));
         assert!(eco.manifest_filenames().contains(&"build.gradle"));
+        assert!(eco.manifest_filenames().contains(&"settings.gradle.kts"));
+        assert!(eco.manifest_filenames().contains(&"settings.gradle"));
     }
 
     #[test]

crates/deps-gradle/src/ecosystem.rs

@@ -5,10 +5,13 @@
 pub mod catalog;
 pub mod groovy;
 pub mod kotlin;
+pub mod properties;
+pub mod settings;
 
 use crate::error::Result;
 use crate::types::GradleDependency;
 use std::any::Any;
+use std::collections::HashMap;
 use tower_lsp_server::ls_types::{Position, Range, Uri};
 
 pub use deps_core::lsp_helpers::LineOffsetTable;
@@ -18,20 +21,61 @@ pub struct GradleParseResult {
     pub uri: Uri,
 }
 
+/// Resolves `$var` and `${var}` references in dependency versions using the given properties map.
+///
+/// If a version is a variable reference and the variable is found in `properties`,
+/// the version is replaced with the resolved value. The version_range is kept as-is
+/// (pointing to the variable reference in source).
+pub fn resolve_variables(deps: &mut [GradleDependency], properties: &HashMap<String, String>) {
+    for dep in deps.iter_mut() {
+        if let Some(ref ver) = dep.version_req
+            && let Some(resolved) = resolve_variable_ref(ver, properties)
+        {
+            dep.version_req = Some(resolved);
+        }
+    }
+}
+
+/// Returns the resolved value if `value` is a `$name` or `${name}` reference. Returns `None` otherwise.
+fn resolve_variable_ref(value: &str, properties: &HashMap<String, String>) -> Option<String> {
+    let trimmed = value.trim();
+    if let Some(name) = trimmed.strip_prefix("${").and_then(|s| s.strip_suffix('}')) {
+        properties.get(name).cloned()
+    } else if let Some(name) = trimmed.strip_prefix('$') {
+        properties.get(name).cloned()
+    } else {
+        None
+    }
+}
+
 pub fn parse_gradle(content: &str, uri: &Uri) -> Result<GradleParseResult> {
     let path = uri.path().to_string();
-    if path.ends_with("libs.versions.toml") {
-        catalog::parse_version_catalog(content, uri)
+    let mut result = if path.ends_with("libs.versions.toml") {
+        catalog::parse_version_catalog(content, uri)?
+    } else if path.ends_with("settings.gradle.kts") || path.ends_with("settings.gradle") {
+        settings::parse_settings(content, uri)?
     } else if path.ends_with(".gradle.kts") {
-        kotlin::parse_kotlin_dsl(content, uri)
+        kotlin::parse_kotlin_dsl(content, uri)?
     } else if path.ends_with(".gradle") {
-        groovy::parse_groovy_dsl(content, uri)
+        groovy::parse_groovy_dsl(content, uri)?
     } else {
-        Ok(GradleParseResult {
+        return Ok(GradleParseResult {
             dependencies: vec![],
             uri: uri.clone(),
-        })
+        });
+    };
+
+    // Resolve variable references for build files (not catalogs or settings)
+    if (path.ends_with("build.gradle.kts") || path.ends_with("build.gradle"))
+        && let Some(dir) = std::path::Path::new(&path).parent()
+    {
+        let props = properties::load_gradle_properties(dir);
+        if !props.is_empty() {
+            resolve_variables(&mut result.dependencies, &props);
+        }
     }
+
+    Ok(result)
 }
 
 impl deps_core::ParseResult for GradleParseResult {
@@ -136,12 +180,94 @@ mod tests {
     }
 
     #[test]
-    fn test_dispatch_unknown() {
+    fn test_dispatch_settings_gradle() {
+        let content = "pluginManagement {\n    plugins {\n        id \"org.jetbrains.kotlin.jvm\" version \"2.1.10\"\n    }\n}\n";
         let uri = make_uri("/project/settings.gradle");
+        let result = parse_gradle(content, &uri).unwrap();
+        assert_eq!(result.dependencies.len(), 1);
+    }
+
+    #[test]
+    fn test_dispatch_settings_gradle_kts() {
+        let content = "pluginManagement {\n    plugins {\n        id(\"org.springframework.boot\") version \"3.2.0\"\n    }\n}\n";
+        let uri = make_uri("/project/settings.gradle.kts");
+        let result = parse_gradle(content, &uri).unwrap();
+        assert_eq!(result.dependencies.len(), 1);
+    }
+
+    #[test]
+    fn test_dispatch_unknown() {
+        let uri = make_uri("/project/something.xml");
         let result = parse_gradle("", &uri).unwrap();
         assert!(result.dependencies.is_empty());
     }
 
+    #[test]
+    fn test_resolve_variables_dollar_brace() {
+        let props: HashMap<String, String> =
+            [("kotlinVersion".to_string(), "2.1.10".to_string())].into();
+        let mut deps = vec![GradleDependency {
+            group_id: "org.jetbrains.kotlin".into(),
+            artifact_id: "kotlin-stdlib".into(),
+            name: "org.jetbrains.kotlin:kotlin-stdlib".into(),
+            name_range: Range::default(),
+            version_req: Some("${kotlinVersion}".into()),
+            version_range: None,
+            configuration: "implementation".into(),
+        }];
+        resolve_variables(&mut deps, &props);
+        assert_eq!(deps[0].version_req, Some("2.1.10".into()));
+    }
+
+    #[test]
+    fn test_resolve_variables_dollar_plain() {
+        let props: HashMap<String, String> =
+            [("springVersion".to_string(), "3.2.0".to_string())].into();
+        let mut deps = vec![GradleDependency {
+            group_id: "org.springframework.boot".into(),
+            artifact_id: "spring-boot-starter".into(),
+            name: "org.springframework.boot:spring-boot-starter".into(),
+            name_range: Range::default(),
+            version_req: Some("$springVersion".into()),
+            version_range: None,
+            configuration: "implementation".into(),
+        }];
+        resolve_variables(&mut deps, &props);
+        assert_eq!(deps[0].version_req, Some("3.2.0".into()));
+    }
+
+    #[test]
+    fn test_resolve_variables_not_found_keeps_raw() {
+        let props: HashMap<String, String> = HashMap::new();
+        let mut deps = vec![GradleDependency {
+            group_id: "com.example".into(),
+            artifact_id: "lib".into(),
+            name: "com.example:lib".into(),
+            name_range: Range::default(),
+            version_req: Some("$unknownVar".into()),
+            version_range: None,
+            configuration: "implementation".into(),
+        }];
+        resolve_variables(&mut deps, &props);
+        assert_eq!(deps[0].version_req, Some("$unknownVar".into()));
+    }
+
+    #[test]
+    fn test_resolve_variables_literal_version_unchanged() {
+        let props: HashMap<String, String> = [("v".to_string(), "9.9.9".to_string())].into();
+        let mut deps = vec![GradleDependency {
+            group_id: "com.example".into(),
+            artifact_id: "lib".into(),
+            name: "com.example:lib".into(),
+            name_range: Range::default(),
+            version_req: Some("1.2.3".into()),
+            version_range: None,
+            configuration: "implementation".into(),
+        }];
+        resolve_variables(&mut deps, &props);
+        assert_eq!(deps[0].version_req, Some("1.2.3".into()));
+    }
+
     #[test]
     fn test_parse_result_trait() {
         use deps_core::ParseResult;

crates/deps-gradle/src/parser/mod.rs

@@ -0,0 +1,103 @@
+//! Parser for gradle.properties files.
+//!
+//! Provides key-value parsing and directory-walking lookup.
+
+use std::collections::HashMap;
+use std::path::Path;
+
+/// Parses a gradle.properties content into key-value pairs.
+///
+/// Lines starting with `#` or empty lines are ignored.
+/// Each line is split on the first `=`.
+pub fn parse_properties(content: &str) -> HashMap<String, String> {
+    content
+        .lines()
+        .filter(|l| !l.trim_start().starts_with('#') && !l.trim().is_empty())
+        .filter_map(|l| l.split_once('='))
+        .map(|(k, v)| (k.trim().to_string(), v.trim().to_string()))
+        .collect()
+}
+
+/// Finds and parses gradle.properties files by walking up from `start_dir`.
+///
+/// Merges properties from all levels, with child values overriding parent values.
+pub fn load_gradle_properties(start_dir: &Path) -> HashMap<String, String> {
+    let mut result = HashMap::new();
+    let mut chain = Vec::new();
+    let mut dir = Some(start_dir);
+
+    while let Some(d) = dir {
+        let props_file = d.join("gradle.properties");
+        if props_file.exists() {
+            chain.push(props_file);
+        }
+        dir = d.parent();
+    }
+
+    // Apply from root to leaf so child values override parent
+    for path in chain.into_iter().rev() {
+        if let Ok(content) = std::fs::read_to_string(&path) {
+            result.extend(parse_properties(&content));
+        }
+    }
+
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_basic() {
+        let content = "kotlinVersion=2.1.10\nspringVersion=3.2.0\n";
+        let props = parse_properties(content);
+        assert_eq!(
+            props.get("kotlinVersion").map(|s| s.as_str()),
+            Some("2.1.10")
+        );
+        assert_eq!(
+            props.get("springVersion").map(|s| s.as_str()),
+            Some("3.2.0")
+        );
+    }
+
+    #[test]
+    fn test_parse_ignores_comments() {
+        let content = "# this is a comment\nkey=value\n";
+        let props = parse_properties(content);
+        assert_eq!(props.len(), 1);
+        assert_eq!(props.get("key").map(|s| s.as_str()), Some("value"));
+    }
+
+    #[test]
+    fn test_parse_ignores_empty_lines() {
+        let content = "\nkey=value\n\n";
+        let props = parse_properties(content);
+        assert_eq!(props.len(), 1);
+    }
+
+    #[test]
+    fn test_parse_trims_whitespace() {
+        let content = "  key  =  value  \n";
+        let props = parse_properties(content);
+        assert_eq!(props.get("key").map(|s| s.as_str()), Some("value"));
+    }
+
+    #[test]
+    fn test_parse_value_with_equals() {
+        // Only splits on the first '='
+        let content = "url=https://example.com?a=b\n";
+        let props = parse_properties(content);
+        assert_eq!(
+            props.get("url").map(|s| s.as_str()),
+            Some("https://example.com?a=b")
+        );
+    }
+
+    #[test]
+    fn test_parse_empty() {
+        let props = parse_properties("");
+        assert!(props.is_empty());
+    }
+}