feat: add Ruby language support

Add comprehensive Ruby language support to gittype including:

## Features Added
- Language detection for .rb files
- Tree-sitter Ruby parser integration
- Code extraction for Ruby constructs:
  - Methods (def)
  - Classes (class)
  - Modules (module)
- Ruby comment processing
- Module chunk type support

## Implementation Details
- Add tree-sitter-ruby dependency
- Extend Language enum with Ruby variant
- Update parser logic for Ruby syntax patterns
- Add constant node type support for Ruby class/module names
- Include Ruby files in default extraction patterns

## Testing
- Add comprehensive Ruby extraction tests
- Test method, class, and module extraction
- Validate name extraction for Ruby constants
- All 95 existing tests continue to pass

Closes #54

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: unhappychoice

Cargo.lock

@@ -24,6 +24,7 @@ tree-sitter = "0.20"
 tree-sitter-rust = "0.20"
 tree-sitter-typescript = "0.20"
 tree-sitter-python = "0.20"
+tree-sitter-ruby = "0.20"
 crossterm = "0.27"
 ratatui = "0.26"
 rusqlite = { version = "0.29", features = ["bundled"] }

Cargo.toml

@@ -345,6 +345,7 @@ impl ChallengeConverter {
             super::Language::Rust => "rust".to_string(),
             super::Language::TypeScript => "typescript".to_string(),
             super::Language::Python => "python".to_string(),
+            super::Language::Ruby => "ruby".to_string(),
         }
     }
 }

src/extractor/challenge_converter.rs

@@ -7,6 +7,7 @@ pub enum ChunkType {
     Class,
     Method,
     Struct,
+    Module,
 }
 
 #[derive(Debug, Clone)]

src/extractor/chunk.rs

@@ -3,6 +3,7 @@ pub enum Language {
     Rust,
     TypeScript,
     Python,
+    Ruby,
 }
 
 impl Language {
@@ -11,6 +12,7 @@ impl Language {
             "rs" => Some(Language::Rust),
             "ts" | "tsx" => Some(Language::TypeScript),
             "py" => Some(Language::Python),
+            "rb" => Some(Language::Ruby),
             _ => None,
         }
     }
@@ -20,6 +22,7 @@ impl Language {
             Language::Rust => "rs",
             Language::TypeScript => "ts",
             Language::Python => "py",
+            Language::Ruby => "rb",
         }
     }
 }

src/extractor/language.rs

@@ -21,6 +21,7 @@ impl Default for ExtractionOptions {
                 "**/*.ts".to_string(),
                 "**/*.tsx".to_string(),
                 "**/*.py".to_string(),
+                "**/*.rb".to_string(),
             ],
             exclude_patterns: vec![
                 "**/target/**".to_string(),
@@ -72,6 +73,16 @@ impl CodeExtractor {
                         ))
                     })?;
             }
+            Language::Ruby => {
+                parser
+                    .set_language(tree_sitter_ruby::language())
+                    .map_err(|e| {
+                        GitTypeError::ExtractionFailed(format!(
+                            "Failed to set Ruby language: {}",
+                            e
+                        ))
+                    })?;
+            }
         }
         Ok(parser)
     }
@@ -253,6 +264,11 @@ impl CodeExtractor {
                 (function_definition name: (identifier) @name) @function
                 (class_definition name: (identifier) @name) @class
             ",
+            Language::Ruby => "
+                (method name: (identifier) @name) @method
+                (class name: (constant) @name) @class
+                (module name: (constant) @name) @module
+            ",
         };
 
         let query = Query::new(tree.language(), query_str).map_err(|e| {
@@ -335,6 +351,7 @@ impl CodeExtractor {
             "method" => ChunkType::Method,
             "class" | "impl" => ChunkType::Class,
             "struct" => ChunkType::Struct,
+            "module" => ChunkType::Module,
             "arrow_function" => ChunkType::Function,
             "function_expression" => ChunkType::Function,
             _ => return None,
@@ -403,6 +420,7 @@ impl CodeExtractor {
                 if child.kind() == "identifier"
                     || child.kind() == "type_identifier"
                     || child.kind() == "property_identifier"
+                    || child.kind() == "constant"
                 {
                     let start = child.start_byte();
                     let end = child.end_byte();
@@ -547,6 +565,7 @@ impl CodeExtractor {
             Language::Rust => "[(line_comment) (block_comment)] @comment",
             Language::TypeScript => "(comment) @comment",
             Language::Python => "(comment) @comment",
+            Language::Ruby => "(comment) @comment",
         };
 
         let query = match Query::new(tree.language(), comment_query) {
@@ -569,6 +588,7 @@ impl CodeExtractor {
                     Language::Rust => node_kind == "line_comment" || node_kind == "block_comment",
                     Language::TypeScript => node_kind == "comment",
                     Language::Python => node_kind == "comment",
+                    Language::Ruby => node_kind == "comment",
                 };
 
                 if !is_valid_comment {

src/extractor/parser.rs

@@ -24,6 +24,7 @@ fn test_language_from_extension() {
     assert_eq!(Language::from_extension("ts"), Some(Language::TypeScript));
     assert_eq!(Language::from_extension("tsx"), Some(Language::TypeScript));
     assert_eq!(Language::from_extension("py"), Some(Language::Python));
+    assert_eq!(Language::from_extension("rb"), Some(Language::Ruby));
     assert_eq!(Language::from_extension("unknown"), None);
 }
 
@@ -334,3 +335,111 @@ class TsClass{} {{
         "Parallel parsing should complete within 5 seconds"
     );
 }
+
+#[test]
+fn test_ruby_function_extraction() {
+    let temp_dir = TempDir::new().unwrap();
+    let file_path = temp_dir.path().join("test.rb");
+
+    let ruby_code = r#"
+def hello_world
+  puts "Hello, world!"
+end
+
+def calculate_sum(a, b)
+  a + b
+end
+"#;
+    fs::write(&file_path, ruby_code).unwrap();
+
+    let mut extractor = CodeExtractor::new().unwrap();
+    let chunks = extractor
+        .extract_chunks(temp_dir.path(), ExtractionOptions::default())
+        .unwrap();
+
+    assert_eq!(chunks.len(), 2);
+    assert_eq!(chunks[0].name, "hello_world");
+    assert_eq!(chunks[1].name, "calculate_sum");
+    assert!(matches!(chunks[0].chunk_type, ChunkType::Method));
+    assert!(matches!(chunks[1].chunk_type, ChunkType::Method));
+}
+
+#[test]
+fn test_ruby_class_extraction() {
+    let temp_dir = TempDir::new().unwrap();
+    let file_path = temp_dir.path().join("test.rb");
+
+    let ruby_code = r#"
+class Person
+  attr_accessor :name, :age
+  
+  def initialize(name, age)
+    @name = name
+    @age = age
+  end
+  
+  def greet
+    puts "Hello, I'm #{@name}!"
+  end
+end
+"#;
+    fs::write(&file_path, ruby_code).unwrap();
+
+    let mut extractor = CodeExtractor::new().unwrap();
+    let chunks = extractor
+        .extract_chunks(temp_dir.path(), ExtractionOptions::default())
+        .unwrap();
+
+    assert_eq!(chunks.len(), 3); // class + 2 methods
+    
+    // Find class chunk
+    let class_chunk = chunks.iter().find(|c| matches!(c.chunk_type, ChunkType::Class)).unwrap();
+    assert_eq!(class_chunk.name, "Person");
+    
+    // Find method chunks
+    let method_chunks: Vec<_> = chunks.iter().filter(|c| matches!(c.chunk_type, ChunkType::Method)).collect();
+    assert_eq!(method_chunks.len(), 2);
+    
+    let method_names: Vec<&String> = method_chunks.iter().map(|c| &c.name).collect();
+    assert!(method_names.contains(&&"initialize".to_string()));
+    assert!(method_names.contains(&&"greet".to_string()));
+}
+
+#[test]
+fn test_ruby_module_extraction() {
+    let temp_dir = TempDir::new().unwrap();
+    let file_path = temp_dir.path().join("test.rb");
+
+    let ruby_code = r#"
+module Authentication
+  def login(username, password)
+    puts "Logging in #{username}"
+    true
+  end
+  
+  def logout
+    puts "Logged out"
+  end
+end
+"#;
+    fs::write(&file_path, ruby_code).unwrap();
+
+    let mut extractor = CodeExtractor::new().unwrap();
+    let chunks = extractor
+        .extract_chunks(temp_dir.path(), ExtractionOptions::default())
+        .unwrap();
+
+    assert_eq!(chunks.len(), 3); // module + 2 methods
+    
+    // Find module chunk
+    let module_chunk = chunks.iter().find(|c| matches!(c.chunk_type, ChunkType::Module)).unwrap();
+    assert_eq!(module_chunk.name, "Authentication");
+    
+    // Find method chunks
+    let method_chunks: Vec<_> = chunks.iter().filter(|c| matches!(c.chunk_type, ChunkType::Method)).collect();
+    assert_eq!(method_chunks.len(), 2);
+    
+    let method_names: Vec<&String> = method_chunks.iter().map(|c| &c.name).collect();
+    assert!(method_names.contains(&&"login".to_string()));
+    assert!(method_names.contains(&&"logout".to_string()));
+}