Refactored language heuristics

Author: ndbroadbent

docs/src/content/docs/features/ambiguity-resolution.mdx

@@ -19,18 +19,31 @@ Renamify uses a sophisticated multi-level approach to resolve ambiguities, tryin
 
 ### 1. Language-Specific Conventions
 
-For known programming languages, Renamify applies language-specific heuristics based on syntactic context.
+For known programming languages, Renamify applies language-specific heuristics based on syntactic context. The system supports over 30 file extensions with intelligent context-aware suggestions.
+
+**Supported Languages:**
+- **Ruby** (.rb, .rake, .gemspec): Classes/modules → PascalCase, methods → snake_case, constants → SCREAMING_SNAKE
+- **Python** (.py, .pyw, .pyi): Classes → PascalCase, functions/decorators → snake_case, constants → SCREAMING_SNAKE
+- **JavaScript/TypeScript** (.js, .jsx, .ts, .tsx, .mjs, .cjs): Classes/interfaces → PascalCase, variables/functions → camelCase, constants → SCREAMING_SNAKE
+- **Go** (.go): Exported types/functions → PascalCase, unexported → camelCase, packages → lowercase
+- **Rust** (.rs): Types → PascalCase, functions/modules → snake_case, constants → SCREAMING_SNAKE, macros → snake_case
+- **Java/Kotlin** (.java, .kt, .kts): Classes → PascalCase, methods/fields → camelCase, constants → SCREAMING_SNAKE
+- **C/C++** (.c, .cpp, .cc, .h, .hpp): Classes/structs → PascalCase or snake_case, macros → SCREAMING_SNAKE
+- **Shell Scripts** (.sh, .bash, .zsh): Environment variables → SCREAMING_SNAKE, functions/locals → snake_case
+- **Web Technologies** (HTML, CSS, YAML, JSON): Attributes/classes → kebab-case, config keys → snake_case or camelCase
 
 **Ruby Example:**
 ```ruby
 # "User" after "class" -> PascalCase expected
 class User
 end
 
-# "API" after "module" -> PascalCase expected
-# (using Active Support Inflections for acronyms)
-module API
+# "process_data" after "def" -> snake_case expected
+def process_data
 end
+
+# "MAX_SIZE" in constant context -> SCREAMING_SNAKE expected
+MAX_SIZE = 100
 ```
 
 **Python Example:**
@@ -40,6 +53,18 @@ def get_user():  # snake_case expected after "def"
 
 class UserModel:  # PascalCase expected after "class"
     pass
+
+@decorator_name  # snake_case expected after "@"
+def method():
+    pass
+```
+
+**JavaScript Example:**
+```javascript
+class UserController { }  // PascalCase after "class"
+const userName = "";      // camelCase after "const"
+const MAX_RETRIES = 3;    // SCREAMING_SNAKE in all-caps context
+process.env.NODE_ENV      // SCREAMING_SNAKE for env vars
 ```
 
 :::note

renamify-core/src/ambiguity/language_heuristics.rs

@@ -1,6 +1,8 @@
 use crate::case_model::Style;
 use std::path::Path;
 
+use super::languages;
+
 /// Language-specific heuristics for resolving case style ambiguity
 pub struct LanguageHeuristics;
 
@@ -19,198 +21,40 @@ impl LanguageHeuristics {
         let context = preceding_context.trim();
 
         match extension {
-            "rb" => Self::ruby_heuristics(context, possible_styles),
-            "py" => Self::python_heuristics(context, possible_styles),
-            "js" | "jsx" | "ts" | "tsx" => Self::javascript_heuristics(context, possible_styles),
-            "go" => Self::go_heuristics(context, possible_styles),
-            "rs" => Self::rust_heuristics(context, possible_styles),
-            "java" => Self::java_heuristics(context, possible_styles),
-            "c" | "cpp" | "cc" | "h" | "hpp" => Self::c_cpp_heuristics(context, possible_styles),
-            "css" | "scss" | "sass" | "less" => Self::css_heuristics(context, possible_styles),
-            "html" | "htm" | "xml" => Self::html_heuristics(context, possible_styles),
-            _ => None,
-        }
-    }
-
-    fn ruby_heuristics(context: &str, possible_styles: &[Style]) -> Option<Style> {
-        if context.ends_with("class") || context.ends_with("module") {
-            // Classes and modules should be PascalCase
-            if possible_styles.contains(&Style::Pascal) {
-                return Some(Style::Pascal);
-            }
-        } else if context.ends_with("def") {
-            // Methods should be snake_case
-            if possible_styles.contains(&Style::Snake) {
-                return Some(Style::Snake);
-            }
-        } else if context.contains("CONSTANT") || context.contains("VERSION") {
-            // Constants are SCREAMING_SNAKE
-            if possible_styles.contains(&Style::ScreamingSnake) {
-                return Some(Style::ScreamingSnake);
-            }
-        }
-        None
-    }
-
-    fn python_heuristics(context: &str, possible_styles: &[Style]) -> Option<Style> {
-        if context.ends_with("class") {
-            // Classes should be PascalCase
-            if possible_styles.contains(&Style::Pascal) {
-                return Some(Style::Pascal);
-            }
-        } else if context.ends_with("def") {
-            // Functions should be snake_case
-            if possible_styles.contains(&Style::Snake) {
-                return Some(Style::Snake);
-            }
-        } else if context
-            .chars()
-            .all(|c| c.is_uppercase() || c == '_' || c == '=')
-        {
-            // Constants (all caps context)
-            if possible_styles.contains(&Style::ScreamingSnake) {
-                return Some(Style::ScreamingSnake);
-            }
-        }
-        None
-    }
-
-    fn javascript_heuristics(context: &str, possible_styles: &[Style]) -> Option<Style> {
-        if context.ends_with("class") || context.ends_with("interface") || context.ends_with("type")
-        {
-            // Classes, interfaces, and types should be PascalCase
-            if possible_styles.contains(&Style::Pascal) {
-                return Some(Style::Pascal);
-            }
-        } else if context.ends_with("function")
-            || context.ends_with("const")
-            || context.ends_with("let")
-            || context.ends_with("var")
-        {
-            // Functions and variables typically camelCase
-            if possible_styles.contains(&Style::Camel) {
-                return Some(Style::Camel);
-            }
-        } else if context.contains("export const")
-            && possible_styles.contains(&Style::ScreamingSnake)
-        {
-            // Exported constants might be SCREAMING_SNAKE
-            return Some(Style::ScreamingSnake);
-        }
-        None
-    }
-
-    fn go_heuristics(context: &str, possible_styles: &[Style]) -> Option<Style> {
-        if context.ends_with("type")
-            || context.ends_with("struct")
-            || context.ends_with("interface")
-        {
-            // Types: PascalCase for exported, camelCase for private
-            // Since we don't know if it's exported, prefer PascalCase if available
-            if possible_styles.contains(&Style::Pascal) {
-                return Some(Style::Pascal);
-            } else if possible_styles.contains(&Style::Camel) {
-                return Some(Style::Camel);
-            }
-        } else if context.ends_with("func") {
-            // Functions: same as types
-            if possible_styles.contains(&Style::Pascal) {
-                return Some(Style::Pascal);
-            } else if possible_styles.contains(&Style::Camel) {
-                return Some(Style::Camel);
-            }
-        }
-        None
-    }
-
-    fn rust_heuristics(context: &str, possible_styles: &[Style]) -> Option<Style> {
-        if context.ends_with("struct")
-            || context.ends_with("enum")
-            || context.ends_with("trait")
-            || context.ends_with("impl")
-        {
-            // Types should be PascalCase
-            if possible_styles.contains(&Style::Pascal) {
-                return Some(Style::Pascal);
-            }
-        } else if context.ends_with("fn") || context.ends_with("let") || context.ends_with("mut") {
-            // Functions and variables should be snake_case
-            if possible_styles.contains(&Style::Snake) {
-                return Some(Style::Snake);
-            }
-        } else if context.ends_with("const") || context.ends_with("static") {
-            // Constants are SCREAMING_SNAKE
-            if possible_styles.contains(&Style::ScreamingSnake) {
-                return Some(Style::ScreamingSnake);
-            }
-        }
-        None
-    }
-
-    fn java_heuristics(context: &str, possible_styles: &[Style]) -> Option<Style> {
-        if context.ends_with("class") || context.ends_with("interface") || context.ends_with("enum")
-        {
-            // Classes should be PascalCase
-            if possible_styles.contains(&Style::Pascal) {
-                return Some(Style::Pascal);
-            }
-        } else if context.contains("private")
-            || context.contains("public")
-            || context.contains("protected")
-        {
-            // Methods and fields typically camelCase
-            if possible_styles.contains(&Style::Camel) {
-                return Some(Style::Camel);
-            }
-        } else if context.ends_with("final") && context.contains("static") {
-            // Constants are SCREAMING_SNAKE
-            if possible_styles.contains(&Style::ScreamingSnake) {
-                return Some(Style::ScreamingSnake);
-            }
-        }
-        None
-    }
+            // Programming languages
+            "rb" | "rake" | "gemspec" => languages::ruby::suggest_style(context, possible_styles),
+            "py" | "pyw" | "pyi" => languages::python::suggest_style(context, possible_styles),
+            "js" | "jsx" | "mjs" | "cjs" | "ts" | "tsx" => {
+                languages::javascript::suggest_style(context, possible_styles)
+            },
+            "go" => languages::go::suggest_style(context, possible_styles),
+            "rs" => languages::rust::suggest_style(context, possible_styles),
+            "java" | "kt" | "kts" => languages::java::suggest_style(context, possible_styles),
+            "c" | "cpp" | "cc" | "cxx" | "h" | "hpp" | "hxx" => {
+                languages::c_cpp::suggest_style(context, possible_styles)
+            },
+
+            // Web technologies
+            "css" | "scss" | "sass" | "less" | "styl" => {
+                languages::css::suggest_style(context, possible_styles)
+            },
+            "html" | "htm" | "xml" | "svg" | "vue" => {
+                languages::html::suggest_style(context, possible_styles)
+            },
+
+            // Shell and scripting
+            "sh" | "bash" | "zsh" | "fish" | "ksh" => {
+                languages::shell::suggest_style(context, possible_styles)
+            },
+
+            // Configuration files
+            "yml" | "yaml" => languages::yaml::suggest_style(context, possible_styles),
+            "json" | "jsonc" | "json5" | "toml" | "ini" | "cfg" | "conf" | "env" => {
+                languages::config::suggest_style(context, possible_styles)
+            },
 
-    fn c_cpp_heuristics(context: &str, possible_styles: &[Style]) -> Option<Style> {
-        if context.ends_with("class") || context.ends_with("struct") {
-            // Classes and structs often PascalCase
-            if possible_styles.contains(&Style::Pascal) {
-                return Some(Style::Pascal);
-            }
-        } else if context.ends_with("#define") {
-            // Macros are SCREAMING_SNAKE
-            if possible_styles.contains(&Style::ScreamingSnake) {
-                return Some(Style::ScreamingSnake);
-            }
-        } else if context.contains("typedef") {
-            // Typedefs often use snake_case or PascalCase
-            if possible_styles.contains(&Style::Pascal) {
-                return Some(Style::Pascal);
-            } else if possible_styles.contains(&Style::Snake) {
-                return Some(Style::Snake);
-            }
-        }
-        None
-    }
-
-    fn css_heuristics(context: &str, possible_styles: &[Style]) -> Option<Style> {
-        // CSS classes and IDs typically use kebab-case
-        if (context.ends_with('.') || context.ends_with('#') || context.contains("class="))
-            && possible_styles.contains(&Style::Kebab)
-        {
-            return Some(Style::Kebab);
-        }
-        None
-    }
-
-    fn html_heuristics(context: &str, possible_styles: &[Style]) -> Option<Style> {
-        // HTML attributes and data attributes use kebab-case
-        if (context.contains("data-") || context.contains("class=") || context.contains("id="))
-            && possible_styles.contains(&Style::Kebab)
-        {
-            return Some(Style::Kebab);
+            _ => None,
         }
-        None
     }
 }
 
@@ -249,18 +93,46 @@ mod tests {
     #[test]
     fn test_javascript_function_heuristic() {
         let path = PathBuf::from("test.js");
-        let possible_styles = vec![Style::Camel, Style::Snake, Style::Kebab];
+        let possible_styles = vec![Style::Camel, Style::Snake];
 
         let result = LanguageHeuristics::suggest_style(&path, "function ", &possible_styles);
         assert_eq!(result, Some(Style::Camel));
     }
 
     #[test]
     fn test_no_matching_style() {
-        let path = PathBuf::from("test.rb");
-        let possible_styles = vec![Style::Camel, Style::Snake]; // No PascalCase
+        let path = PathBuf::from("test.py");
+        let possible_styles = vec![Style::Kebab]; // Python doesn't use kebab
 
-        let result = LanguageHeuristics::suggest_style(&path, "class ", &possible_styles);
-        assert_eq!(result, None); // Can't suggest PascalCase if it's not possible
+        let result = LanguageHeuristics::suggest_style(&path, "def ", &possible_styles);
+        assert_eq!(result, None);
+    }
+
+    #[test]
+    fn test_unsupported_extension() {
+        let path = PathBuf::from("test.xyz");
+        let possible_styles = vec![Style::Snake, Style::Camel];
+
+        let result = LanguageHeuristics::suggest_style(&path, "function ", &possible_styles);
+        assert_eq!(result, None);
+    }
+
+    #[test]
+    fn test_shell_export_heuristic() {
+        let path = PathBuf::from("script.sh");
+        let possible_styles = vec![Style::ScreamingSnake, Style::Snake];
+
+        // Note: "export " gets trimmed to "export" in suggest_style
+        let result = LanguageHeuristics::suggest_style(&path, "export ", &possible_styles);
+        assert_eq!(result, Some(Style::ScreamingSnake));
+    }
+
+    #[test]
+    fn test_yaml_key_heuristic() {
+        let path = PathBuf::from("config.yml");
+        let possible_styles = vec![Style::Snake, Style::Camel];
+
+        let result = LanguageHeuristics::suggest_style(&path, "key:", &possible_styles);
+        assert_eq!(result, Some(Style::Snake));
     }
 }