diff --git a/README.md b/README.md
index b2007f3..2e6cdbe 100644
--- a/README.md
+++ b/README.md
@@ -61,7 +61,7 @@ ASTChunk depends on [tree-sitter](https://tree-sitter.github.io/tree-sitter/) fo
 ```bash
 # Core dependencies (automatically installed)
 pip install numpy pyrsistent tree-sitter
-pip install tree-sitter-python tree-sitter-java tree-sitter-c-sharp tree-sitter-typescript
+pip install tree-sitter-python tree-sitter-java tree-sitter-c-sharp tree-sitter-typescript tree-sitter-ruby
 ```
 
 ## Configuration Options
@@ -96,7 +96,7 @@ class Calculator:
 # Initialize the chunk builder
 configs = {
     "max_chunk_size": 100,             # Maximum non-whitespace characters per chunk
-    "language": "python",              # Supported: python, java, csharp, typescript
+    "language": "python",              # Supported: python, java, csharp, typescript, ruby
     "metadata_template": "default"     # Metadata format for output
 }
 chunk_builder = ASTChunkBuilder(**configs)
@@ -207,6 +207,13 @@ ts_builder = ASTChunkBuilder(
     language="typescript",
     metadata_template="default"
 )
+
+# Ruby code
+ruby_builder = ASTChunkBuilder(
+    max_chunk_size=1500,
+    language="ruby",
+    metadata_template="default"
+)
 ```
 
 <!-- ### Metadata Templates
@@ -263,6 +270,7 @@ from astchunk.astchunk import ASTChunk
 | Java       | `.java`        | ✅ Full support |
 | C#         | `.cs`          | ✅ Full support |
 | TypeScript | `.ts`, `.tsx`  | ✅ Full support |
+| Ruby       | `.rb`          | ✅ Full support |
 
 <!-- ## Contributing
 
diff --git a/data/code_samples/calculator.rb b/data/code_samples/calculator.rb
new file mode 100644
index 0000000..f17c7bd
--- /dev/null
+++ b/data/code_samples/calculator.rb
@@ -0,0 +1,372 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+require 'bigdecimal/util'
+
+# A comprehensive Ruby calculator example showing various language constructs
+module MathUtils
+  PI = 3.14159265359.freeze
+  E = 2.71828182846.freeze
+
+  # Helper module for common mathematical operations
+  module Helpers
+    def self.factorial(n)
+      return 1 if n <= 1
+      (1..n).inject(:*)
+    end
+
+    def self.fibonacci(n)
+      return n if n <= 1
+      fibonacci(n - 1) + fibonacci(n - 2)
+    end
+  end
+
+  # Main calculator class with comprehensive functionality
+  class Calculator
+    include Helpers
+
+    attr_reader :history, :precision
+    attr_accessor :decimal_places
+
+    def initialize(precision: 10, decimal_places: 2)
+      @history = []
+      @precision = precision
+      @decimal_places = decimal_places
+      @memory = BigDecimal('0')
+    end
+
+    # Basic arithmetic operations
+    def add(a, b)
+      result = to_decimal(a) + to_decimal(b)
+      log_operation(:add, [a, b], result)
+      format_result(result)
+    end
+
+    def subtract(a, b)
+      result = to_decimal(a) - to_decimal(b)
+      log_operation(:subtract, [a, b], result)
+      format_result(result)
+    end
+
+    def multiply(a, b)
+      result = to_decimal(a) * to_decimal(b)
+      log_operation(:multiply, [a, b], result)
+      format_result(result)
+    end
+
+    def divide(a, b)
+      raise ArgumentError, "Cannot divide by zero" if b.to_f.zero?
+      
+      result = to_decimal(a) / to_decimal(b)
+      log_operation(:divide, [a, b], result)
+      format_result(result)
+    end
+
+    def power(base, exponent)
+      result = to_decimal(base) ** exponent.to_i
+      log_operation(:power, [base, exponent], result)
+      format_result(result)
+    end
+
+    # Advanced mathematical functions
+    def square_root(n)
+      raise ArgumentError, "Cannot calculate square root of negative number" if n.to_f < 0
+      
+      result = Math.sqrt(n.to_f)
+      log_operation(:sqrt, [n], result)
+      format_result(result)
+    end
+
+    def logarithm(n, base = Math::E)
+      raise ArgumentError, "Cannot calculate logarithm of non-positive number" if n.to_f <= 0
+      
+      result = Math.log(n.to_f) / Math.log(base.to_f)
+      log_operation(:log, [n, base], result)
+      format_result(result)
+    end
+
+    # Trigonometric functions
+    def sin(angle_degrees)
+      radians = angle_degrees * Math::PI / 180
+      result = Math.sin(radians)
+      log_operation(:sin, [angle_degrees], result)
+      format_result(result)
+    end
+
+    def cos(angle_degrees)
+      radians = angle_degrees * Math::PI / 180
+      result = Math.cos(radians)
+      log_operation(:cos, [angle_degrees], result)
+      format_result(result)
+    end
+
+    def tan(angle_degrees)
+      radians = angle_degrees * Math::PI / 180
+      result = Math.tan(radians)
+      log_operation(:tan, [angle_degrees], result)
+      format_result(result)
+    end
+
+    # Memory operations
+    def memory_store(value)
+      @memory = to_decimal(value)
+      log_operation(:memory_store, [value], @memory)
+      @memory
+    end
+
+    def memory_recall
+      format_result(@memory)
+    end
+
+    def memory_clear
+      @memory = BigDecimal('0')
+      log_operation(:memory_clear, [], @memory)
+      format_result(@memory)
+    end
+
+    def memory_add(value)
+      @memory += to_decimal(value)
+      log_operation(:memory_add, [value], @memory)
+      format_result(@memory)
+    end
+
+    # History and utility methods
+    def clear_history
+      @history.clear
+      "History cleared"
+    end
+
+    def last_result
+      return nil if @history.empty?
+      @history.last[:result]
+    end
+
+    def show_history(limit = 10)
+      @history.last(limit).map.with_index do |entry, index|
+        "#{index + 1}. #{entry[:operation]} #{entry[:operands].join(', ')} = #{entry[:result]}"
+      end
+    end
+
+    # Class methods for quick calculations
+    class << self
+      def quick_add(a, b)
+        new.add(a, b)
+      end
+
+      def quick_multiply(a, b)
+        new.multiply(a, b)
+      end
+
+      def percentage(value, percent)
+        new.multiply(value, percent / 100.0)
+      end
+    end
+
+    private
+
+    def to_decimal(value)
+      case value
+      when BigDecimal
+        value
+      when String
+        BigDecimal(value)
+      else
+        BigDecimal(value.to_s)
+      end
+    rescue ArgumentError
+      raise ArgumentError, "Invalid number format: #{value}"
+    end
+
+    def format_result(result)
+      if result.is_a?(BigDecimal)
+        result.round(@decimal_places).to_f
+      else
+        result.round(@decimal_places)
+      end
+    end
+
+    def log_operation(operation, operands, result)
+      @history << {
+        operation: operation,
+        operands: operands,
+        result: format_result(result),
+        timestamp: Time.now
+      }
+      
+      # Keep only last 100 operations
+      @history = @history.last(100) if @history.length > 100
+    end
+  end
+
+  # Scientific calculator extending basic calculator
+  class ScientificCalculator < Calculator
+    def initialize(**options)
+      super(**options)
+      @angle_mode = :degrees  # :degrees or :radians
+    end
+
+    attr_accessor :angle_mode
+
+    def factorial(n)
+      raise ArgumentError, "Factorial only defined for non-negative integers" unless n.is_a?(Integer) && n >= 0
+      
+      result = Helpers.factorial(n)
+      log_operation(:factorial, [n], result)
+      result
+    end
+
+    def fibonacci(n)
+      raise ArgumentError, "Fibonacci only defined for non-negative integers" unless n.is_a?(Integer) && n >= 0
+      
+      result = Helpers.fibonacci(n)
+      log_operation(:fibonacci, [n], result)
+      result
+    end
+
+    def combination(n, r)
+      raise ArgumentError, "Invalid combination parameters" unless n >= r && r >= 0
+      
+      result = factorial(n) / (factorial(r) * factorial(n - r))
+      log_operation(:combination, [n, r], result)
+      result
+    end
+
+    def permutation(n, r)
+      raise ArgumentError, "Invalid permutation parameters" unless n >= r && r >= 0
+      
+      result = factorial(n) / factorial(n - r)
+      log_operation(:permutation, [n, r], result)
+      result
+    end
+
+    # Convert angle based on current mode
+    def to_radians(angle)
+      case @angle_mode
+      when :degrees
+        angle * Math::PI / 180
+      when :radians
+        angle
+      else
+        raise ArgumentError, "Unknown angle mode: #{@angle_mode}"
+      end
+    end
+
+    # Override trigonometric functions to respect angle mode
+    def sin(angle)
+      radians = to_radians(angle)
+      result = Math.sin(radians)
+      log_operation(:sin, [angle], result)
+      format_result(result)
+    end
+
+    def cos(angle)
+      radians = to_radians(angle)
+      result = Math.cos(radians)
+      log_operation(:cos, [angle], result)
+      format_result(result)
+    end
+
+    def tan(angle)
+      radians = to_radians(angle)
+      result = Math.tan(radians)
+      log_operation(:tan, [angle], result)
+      format_result(result)
+    end
+  end
+
+  # Rails-style concern for calculation validation
+  module CalculationValidation
+    extend ActiveSupport::Concern if defined?(ActiveSupport)
+
+    included do
+      validate :validate_numeric_inputs, if: :should_validate?
+    end
+
+    class_methods do
+      def valid_number?(value)
+        Float(value.to_s)
+        true
+      rescue ArgumentError, TypeError
+        false
+      end
+    end
+
+    private
+
+    def validate_numeric_inputs
+      return unless @last_inputs
+
+      @last_inputs.each_with_index do |input, index|
+        unless self.class.valid_number?(input)
+          errors.add(:base, "Input #{index + 1} is not a valid number: #{input}")
+        end
+      end
+    end
+
+    def should_validate?
+      defined?(@last_inputs) && @last_inputs.any?
+    end
+  end
+end
+
+# Singleton class for global calculator instance
+class GlobalCalculator
+  include Singleton
+  
+  def initialize
+    @calculator = MathUtils::Calculator.new
+  end
+
+  def method_missing(method, *args, **kwargs)
+    if @calculator.respond_to?(method)
+      @calculator.send(method, *args, **kwargs)
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(method, include_private = false)
+    @calculator.respond_to?(method, include_private) || super
+  end
+
+  class << self
+    def calculate(&block)
+      instance.instance_eval(&block)
+    end
+  end
+end
+
+# Example usage and demonstration
+if __FILE__ == $PROGRAM_NAME
+  calc = MathUtils::Calculator.new(decimal_places: 3)
+  
+  puts "Basic operations:"
+  puts "5 + 3 = #{calc.add(5, 3)}"
+  puts "10 - 4 = #{calc.subtract(10, 4)}"
+  puts "6 * 7 = #{calc.multiply(6, 7)}"
+  puts "15 / 3 = #{calc.divide(15, 3)}"
+  puts "2^8 = #{calc.power(2, 8)}"
+  
+  puts "\nAdvanced operations:"
+  puts "√16 = #{calc.square_root(16)}"
+  puts "ln(e) = #{calc.logarithm(Math::E)}"
+  puts "sin(90°) = #{calc.sin(90)}"
+  
+  puts "\nHistory:"
+  calc.show_history.each { |entry| puts entry }
+  
+  # Scientific calculator
+  sci_calc = MathUtils::ScientificCalculator.new
+  sci_calc.angle_mode = :radians
+  
+  puts "\nScientific operations:"
+  puts "5! = #{sci_calc.factorial(5)}"
+  puts "fib(10) = #{sci_calc.fibonacci(10)}"
+  puts "C(5,2) = #{sci_calc.combination(5, 2)}"
+  
+  # Global calculator usage
+  result = GlobalCalculator.calculate do
+    add(multiply(2, 3), divide(10, 2))
+  end
+  puts "\nGlobal calculator result: #{result}"
+end
\ No newline at end of file
diff --git a/examples/outputs/ast_chunking_with_expansion_results.txt b/examples/outputs/ast_chunking_with_expansion_results.txt
index d866302..b65d62e 100644
--- a/examples/outputs/ast_chunking_with_expansion_results.txt
+++ b/examples/outputs/ast_chunking_with_expansion_results.txt
@@ -1,9 +1,10 @@
 AST Chunking Results (max 1800 non-whitespace chars per chunk)
 ================================================================================
 
-------------------------- Chunk 1 (78 lines / 1613 chars) -------------------------
+------------------------- Chunk 1 (79 lines / 1613 chars) -------------------------
 '''
 imagen-pytorch/blob/main/imagen_pytorch/trainer.py
+"""
 '''
 """
 https://github.com/lucidrains/imagen-pytorch/blob/main/imagen_pytorch/trainer.py
@@ -82,9 +83,10 @@ def group_by_key_prefix(prefix, d):
     return group_dict_by_key(partial(string_begins_with, prefix), d)
 -----------------------------------------------------------------------------------
 
-------------------------- Chunk 2 (67 lines / 1671 chars) -------------------------
+------------------------- Chunk 2 (68 lines / 1671 chars) -------------------------
 '''
 imagen-pytorch/blob/main/imagen_pytorch/trainer.py
+"""
 '''
 def groupby_prefix_and_trim(prefix, d):
     kwargs_with_prefix, kwargs = group_dict_by_key(partial(string_begins_with, prefix), d)
@@ -152,9 +154,10 @@ def cast_torch_tensor(fn, cast_fp16 = False):
 # gradient accumulation functions
 -----------------------------------------------------------------------------------
 
-------------------------- Chunk 3 (52 lines / 1370 chars) -------------------------
+------------------------- Chunk 3 (53 lines / 1370 chars) -------------------------
 '''
 imagen-pytorch/blob/main/imagen_pytorch/trainer.py
+"""
 '''
 def split_iterable(it, split_size):
     accum = []
@@ -207,9 +210,10 @@ def split_args_and_kwargs(*args, split_size = None, **kwargs):
 # imagen trainer
 -----------------------------------------------------------------------------------
 
-------------------------- Chunk 4 (36 lines / 980 chars) -------------------------
+------------------------- Chunk 4 (37 lines / 980 chars) -------------------------
 '''
 imagen-pytorch/blob/main/imagen_pytorch/trainer.py
+"""
 '''
 def imagen_sample_in_chunks(fn):
     @wraps(fn)
@@ -246,10 +250,11 @@ def restore_parts(state_dict_target, state_dict_from):
     return state_dict_target
 ----------------------------------------------------------------------------------
 
-------------------------- Chunk 5 (36 lines / 598 chars) -------------------------
+------------------------- Chunk 5 (37 lines / 598 chars) -------------------------
 '''
 imagen-pytorch/blob/main/imagen_pytorch/trainer.py
-class ImagenTrainer(nn.Module):
+"""
+	class ImagenTrainer(nn.Module):
 '''
 class ImagenTrainer(nn.Module):
     locked = False
@@ -285,11 +290,12 @@ class ImagenTrainer(nn.Module):
     ):
 ----------------------------------------------------------------------------------
 
-------------------------- Chunk 6 (64 lines / 1785 chars) -------------------------
+------------------------- Chunk 6 (65 lines / 1785 chars) -------------------------
 '''
 imagen-pytorch/blob/main/imagen_pytorch/trainer.py
-class ImagenTrainer(nn.Module):
-	def __init__(
+"""
+	class ImagenTrainer(nn.Module):
+		def __init__(
 '''
         super().__init__()
         assert not ImagenTrainer.locked, 'ImagenTrainer can only be initialized once per process - for the sake of distributed training, you will now have to create a separate script to train each unet (or a script that accepts unet number as an argument)'
@@ -352,11 +358,12 @@ class ImagenTrainer(nn.Module):
         self.train_dl = None
 -----------------------------------------------------------------------------------
 
-------------------------- Chunk 7 (74 lines / 1783 chars) -------------------------
+------------------------- Chunk 7 (75 lines / 1783 chars) -------------------------
 '''
 imagen-pytorch/blob/main/imagen_pytorch/trainer.py
-class ImagenTrainer(nn.Module):
-	def __init__(
+"""
+	class ImagenTrainer(nn.Module):
+		def __init__(
 '''
         self.valid_dl_iter = None
         self.valid_dl = None
@@ -429,11 +436,12 @@ class ImagenTrainer(nn.Module):
         assert not (exists(checkpoint_path) ^ exists(checkpoint_every))
 -----------------------------------------------------------------------------------
 
-------------------------- Chunk 8 (76 lines / 1776 chars) -------------------------
+------------------------- Chunk 8 (77 lines / 1776 chars) -------------------------
 '''
 imagen-pytorch/blob/main/imagen_pytorch/trainer.py
-class ImagenTrainer(nn.Module):
-	def __init__(
+"""
+	class ImagenTrainer(nn.Module):
+		def __init__(
 '''
         self.checkpoint_path = checkpoint_path
         self.checkpoint_every = checkpoint_every
@@ -508,10 +516,11 @@ class ImagenTrainer(nn.Module):
         self.wrap_unet(unet_number)
 -----------------------------------------------------------------------------------
 
-------------------------- Chunk 9 (73 lines / 1789 chars) -------------------------
+------------------------- Chunk 9 (74 lines / 1789 chars) -------------------------
 '''
 imagen-pytorch/blob/main/imagen_pytorch/trainer.py
-class ImagenTrainer(nn.Module):
+"""
+	class ImagenTrainer(nn.Module):
 '''
     def wrap_unet(self, unet_number):
         if hasattr(self, 'one_unet_wrapped'):
@@ -584,10 +593,11 @@ class ImagenTrainer(nn.Module):
         return self.steps[unet_number - 1].item()
 -----------------------------------------------------------------------------------
 
-------------------------- Chunk 10 (65 lines / 1719 chars) -------------------------
+------------------------- Chunk 10 (66 lines / 1719 chars) -------------------------
 '''
 imagen-pytorch/blob/main/imagen_pytorch/trainer.py
-class ImagenTrainer(nn.Module):
+"""
+	class ImagenTrainer(nn.Module):
 '''
     def print_untrained_unets(self):
         print_final_error = False
@@ -652,10 +662,11 @@ class ImagenTrainer(nn.Module):
         self.add_valid_dataloader(dl)
 ------------------------------------------------------------------------------------
 
-------------------------- Chunk 11 (70 lines / 1782 chars) -------------------------
+------------------------- Chunk 11 (71 lines / 1782 chars) -------------------------
 '''
 imagen-pytorch/blob/main/imagen_pytorch/trainer.py
-class ImagenTrainer(nn.Module):
+"""
+	class ImagenTrainer(nn.Module):
 '''
     def create_train_iter(self):
         assert exists(self.train_dl), 'training dataloader has not been registered with the trainer yet'
@@ -725,10 +736,11 @@ class ImagenTrainer(nn.Module):
         self.load(last_checkpoint)
 ------------------------------------------------------------------------------------
 
-------------------------- Chunk 12 (25 lines / 473 chars) -------------------------
+------------------------- Chunk 12 (26 lines / 473 chars) -------------------------
 '''
 imagen-pytorch/blob/main/imagen_pytorch/trainer.py
-class ImagenTrainer(nn.Module):
+"""
+	class ImagenTrainer(nn.Module):
 '''
     def save_to_checkpoint_folder(self):
         self.accelerator.wait_for_everyone()
@@ -753,10 +765,11 @@ class ImagenTrainer(nn.Module):
     # saving and loading functions
 -----------------------------------------------------------------------------------
 
-------------------------- Chunk 13 (70 lines / 1431 chars) -------------------------
+------------------------- Chunk 13 (71 lines / 1431 chars) -------------------------
 '''
 imagen-pytorch/blob/main/imagen_pytorch/trainer.py
-class ImagenTrainer(nn.Module):
+"""
+	class ImagenTrainer(nn.Module):
 '''
     def save(
         self,
@@ -826,11 +839,12 @@ class ImagenTrainer(nn.Module):
         self.print(f'checkpoint saved to {path}')
 ------------------------------------------------------------------------------------
 
-------------------------- Chunk 14 (59 lines / 1655 chars) -------------------------
+------------------------- Chunk 14 (60 lines / 1655 chars) -------------------------
 '''
 imagen-pytorch/blob/main/imagen_pytorch/trainer.py
-class ImagenTrainer(nn.Module):
-	def load(self, path, only_model = False, strict = True, noop_if_not_exist = False):
+"""
+	class ImagenTrainer(nn.Module):
+		def load(self, path, only_model = False, strict = True, noop_if_not_exist = False):
 '''
     def load(self, path, only_model = False, strict = True, noop_if_not_exist = False):
         fs = self.fs
@@ -888,11 +902,12 @@ class ImagenTrainer(nn.Module):
                     self.print('could not load optimizer and scaler, possibly because you have turned on mixed precision training since the last run. resuming with new optimizer and scalers')
 ------------------------------------------------------------------------------------
 
-------------------------- Chunk 15 (16 lines / 322 chars) -------------------------
+------------------------- Chunk 15 (17 lines / 322 chars) -------------------------
 '''
 imagen-pytorch/blob/main/imagen_pytorch/trainer.py
-class ImagenTrainer(nn.Module):
-	def load(self, path, only_model = False, strict = True, noop_if_not_exist = False):
+"""
+	class ImagenTrainer(nn.Module):
+		def load(self, path, only_model = False, strict = True, noop_if_not_exist = False):
 '''
         if self.use_ema:
             assert 'ema' in loaded_obj
@@ -907,10 +922,11 @@ class ImagenTrainer(nn.Module):
         return loaded_obj
 -----------------------------------------------------------------------------------
 
-------------------------- Chunk 16 (83 lines / 1754 chars) -------------------------
+------------------------- Chunk 16 (84 lines / 1754 chars) -------------------------
 '''
 imagen-pytorch/blob/main/imagen_pytorch/trainer.py
-class ImagenTrainer(nn.Module):
+"""
+	class ImagenTrainer(nn.Module):
 '''
     # managing ema unets and their devices
 
@@ -993,10 +1009,11 @@ class ImagenTrainer(nn.Module):
         return super().state_dict(*args, **kwargs)
 ------------------------------------------------------------------------------------
 
-------------------------- Chunk 17 (75 lines / 1745 chars) -------------------------
+------------------------- Chunk 17 (76 lines / 1745 chars) -------------------------
 '''
 imagen-pytorch/blob/main/imagen_pytorch/trainer.py
-class ImagenTrainer(nn.Module):
+"""
+	class ImagenTrainer(nn.Module):
 '''
     def load_state_dict(self, *args, **kwargs):
         self.reset_ema_unets_all_one_device()
@@ -1071,10 +1088,11 @@ class ImagenTrainer(nn.Module):
         return output
 ------------------------------------------------------------------------------------
 
-------------------------- Chunk 18 (31 lines / 764 chars) -------------------------
+------------------------- Chunk 18 (32 lines / 764 chars) -------------------------
 '''
 imagen-pytorch/blob/main/imagen_pytorch/trainer.py
-class ImagenTrainer(nn.Module):
+"""
+	class ImagenTrainer(nn.Module):
 '''
     @partial(cast_torch_tensor, cast_fp16 = True)
     def forward(
diff --git a/examples/ruby_demo.py b/examples/ruby_demo.py
new file mode 100644
index 0000000..38e98ae
--- /dev/null
+++ b/examples/ruby_demo.py
@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+"""
+Ruby chunking demonstration for ASTChunk.
+
+This example shows how to use ASTChunk with Ruby code, demonstrating
+the recognition of Ruby-specific constructs like modules, classes, and methods.
+"""
+
+from astchunk import ASTChunkBuilder
+
+
+def main():
+    """Demonstrate Ruby chunking capabilities."""
+    
+    # Ruby code example with various constructs
+    ruby_code = """
+module UserManagement
+  class User
+    attr_reader :name, :email
+    attr_accessor :status
+    
+    def initialize(name, email)
+      @name = name
+      @email = email
+      @status = :active
+    end
+    
+    def activate!
+      @status = :active
+      notify_activation
+    end
+    
+    def deactivate!
+      @status = :inactive
+      notify_deactivation
+    end
+    
+    private
+    
+    def notify_activation
+      puts "User #{@name} has been activated"
+    end
+    
+    def notify_deactivation
+      puts "User #{@name} has been deactivated"
+    end
+  end
+  
+  class AdminUser < User
+    def initialize(name, email)
+      super(name, email)
+      @permissions = [:read, :write, :admin]
+    end
+    
+    def grant_permission(permission)
+      @permissions << permission unless @permissions.include?(permission)
+    end
+    
+    def has_permission?(permission)
+      @permissions.include?(permission)
+    end
+  end
+  
+  module Authentication
+    def self.authenticate(user, password)
+      # Simple authentication logic
+      user.status == :active && verify_password(user, password)
+    end
+    
+    private
+    
+    def self.verify_password(user, password)
+      # In a real app, this would check against a secure hash
+      password.length >= 8
+    end
+  end
+end
+"""
+    
+    print("Ruby/Rails ASTChunk Demo")
+    print("=" * 50)
+    
+    # Configure the chunk builder for Ruby
+    config = {
+        "max_chunk_size": 400,  # Moderate chunk size
+        "language": "ruby",
+        "metadata_template": "default"
+    }
+    
+    chunk_builder = ASTChunkBuilder(**config)
+    
+    # Add repository-level metadata
+    repo_metadata = {
+        "filepath": "app/models/user_management.rb"
+    }
+    
+    # Perform chunking
+    chunks = chunk_builder.chunkify(ruby_code, 
+                                   repo_level_metadata=repo_metadata)
+    
+    print(f"Generated {len(chunks)} chunks from Ruby code")
+    print(f"Original code: {len(ruby_code)} characters")
+    print()
+    
+    # Display chunk information
+    for i, chunk in enumerate(chunks):
+        content = chunk['content']
+        metadata = chunk['metadata']
+        
+        print(f"Chunk {i+1}:")
+        print(f"  File: {metadata['filepath']}")
+        print(f"  Lines: {metadata['start_line_no']}-{metadata['end_line_no']} ({metadata['line_count']} lines)")
+        print(f"  Size: {metadata['chunk_size']} non-whitespace characters")
+        print(f"  AST Nodes: {metadata['node_count']}")
+        
+        # Show Ruby constructs found
+        ruby_keywords = ['module', 'class', 'def ', 'attr_reader', 'attr_accessor', 'include', 'extend']
+        found_keywords = [kw for kw in ruby_keywords if kw in content]
+        if found_keywords:
+            print(f"  Ruby constructs: {', '.join(found_keywords)}")
+        
+        # Show a preview of the content
+        preview = content.strip().split('\n')[0]
+        if len(preview) > 60:
+            preview = preview[:57] + "..."
+        print(f"  Preview: {preview}")
+        print()
+    
+    # Demonstrate chunk expansion
+    print("=" * 50)
+    print("Chunk Expansion Demo")
+    print("=" * 50)
+    
+    # Create chunks with expansion enabled
+    expanded_chunks = chunk_builder.chunkify(
+        ruby_code,
+        repo_level_metadata=repo_metadata,
+        chunk_expansion=True
+    )
+    
+    if expanded_chunks:
+        first_chunk = expanded_chunks[0]
+        print("First chunk with expansion:")
+        print(first_chunk['content'][:300] + "..." if len(first_chunk['content']) > 300 else first_chunk['content'])
+    
+    print("\n🎉 Ruby chunking demonstration completed!")
+
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/pyproject.toml b/pyproject.toml
index 6774372..2981d82 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -44,7 +44,8 @@ dependencies = [
     "tree-sitter-python>=0.20.0",
     "tree-sitter-java>=0.20.0",
     "tree-sitter-c-sharp>=0.20.0",
-    "tree-sitter-typescript>=0.20.0"
+    "tree-sitter-typescript>=0.20.0",
+    "tree-sitter-ruby>=0.20.0"
 ]
 
 [project.optional-dependencies]
diff --git a/requirements.txt b/requirements.txt
index 25b5a54..39cb112 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -5,3 +5,4 @@ tree-sitter-python
 tree-sitter-java
 tree-sitter-c-sharp
 tree-sitter-typescript
+tree-sitter-ruby
diff --git a/src/astchunk/astchunk.py b/src/astchunk/astchunk.py
index f14356c..f0de634 100644
--- a/src/astchunk/astchunk.py
+++ b/src/astchunk/astchunk.py
@@ -103,27 +103,36 @@ def rebuild_code(self, ast_window: list[ASTNode]) -> str:
 
     def build_chunk_ancestors(self, node_ancestors: list[ASTNode]) -> list[ASTNode]:
         '''
-        Build the class/function path to the chunk. The path is built from the ancestors of the first 
-        ASTNode in the window. We only keep the ancestors that are class or function definitions.
+        Build the class/function/module path to the chunk. The path is built from the ancestors of the first 
+        ASTNode in the window. We keep the ancestors that are class, function, or module definitions.
 
         The intuition is that we want to record where the chunk is located in the AST. This can be useful
         for downstream tasks such as code retrieval (e.g., disambiguating between different functions with the same name).
-        For each ancestor that is a class or function definition, we extract the first line in the ancestor's text.
+        For each ancestor that is a class, function, or module definition, we extract the first line in the ancestor's text.
         This simple heuristic is also commonly used in software patching tasks, such as generating GitHub issue fixes, 
         where identifying the location of a change is an essential part of the patch.
 
+        Supported constructs:
+        - Python: class_definition, function_definition
+        - Ruby: class, module, method, singleton_method, singleton_class
+
         Args:
             node_ancestors: list of tree-sitter nodes that are ancestors of the first ASTNode in the window
 
         Returns:
-            List of ancestors that are class or function definitions
+            List of ancestors that are class, function, or module definitions
         '''
         chunk_ancestors = []
 
         for node in node_ancestors:
             if any([
                 node.type == "class_definition",
-                node.type == "function_definition"
+                node.type == "function_definition",
+                node.type == "class",
+                node.type == "module",
+                node.type == "method",
+                node.type == "singleton_method",
+                node.type == "singleton_class"
             ]):
                 chunk_ancestors.append(node.text.decode("utf8").split("\n")[0])
 
diff --git a/src/astchunk/astchunk_builder.py b/src/astchunk/astchunk_builder.py
index da08364..a9445a1 100644
--- a/src/astchunk/astchunk_builder.py
+++ b/src/astchunk/astchunk_builder.py
@@ -6,6 +6,7 @@
 import tree_sitter_java as tsjava
 import tree_sitter_c_sharp as tscsharp
 import tree_sitter_typescript as tstypescript
+import tree_sitter_ruby as tsruby
 import pyrsistent
 
 from astchunk.astnode import ASTNode
@@ -21,7 +22,7 @@ class ASTChunkBuilder():
     """
     Attributes:
         - max_chunk_size: Maximum size for each AST chunk, using non-whitespace character count by default.
-        - language: Supported languages, currently including python, java, c# and typescript.
+        - language: Supported languages, currently including python, java, c#, typescript, and ruby.
         - metadata_template: Type of metadata to store (e.g., start/end line number, path to file, etc).
     """
     def __init__(self, **configs):
@@ -37,6 +38,8 @@ def __init__(self, **configs):
             self.parser = ts.Parser(ts.Language(tscsharp.language()))
         elif self.language == "typescript":
             self.parser = ts.Parser(ts.Language(tstypescript.language_tsx()))
+        elif self.language == "ruby":
+            self.parser = ts.Parser(ts.Language(tsruby.language()))
         else:
             raise ValueError(f"Unsupported Programming Language: {self.language}!")
 
diff --git a/tests/test_ruby_support.py b/tests/test_ruby_support.py
new file mode 100644
index 0000000..5338429
--- /dev/null
+++ b/tests/test_ruby_support.py
@@ -0,0 +1,568 @@
+"""
+Tests for Ruby language support in ASTChunk.
+
+This module tests the Ruby-specific functionality including:
+- Class and module definition recognition
+- Method chunking (instance, class, singleton methods)
+- Rails-style patterns
+- Ruby-specific syntax constructs
+"""
+
+import pytest
+from astchunk import ASTChunkBuilder
+
+
+class TestRubySupport:
+    """Test suite for Ruby language support."""
+
+    def setup_method(self):
+        """Set up test fixtures before each test method."""
+        self.config = {
+            "max_chunk_size": 200,
+            "language": "ruby",
+            "metadata_template": "default"
+        }
+        self.chunk_builder = ASTChunkBuilder(**self.config)
+
+    def test_ruby_parser_initialization(self):
+        """Test that Ruby parser initializes correctly."""
+        assert self.chunk_builder.language == "ruby"
+        assert self.chunk_builder.parser is not None
+
+    def test_simple_ruby_class_chunking(self):
+        """Test chunking of a simple Ruby class."""
+        ruby_code = """
+class Calculator
+  def initialize
+    @value = 0
+  end
+
+  def add(number)
+    @value += number
+  end
+
+  def subtract(number)
+    @value -= number
+  end
+
+  def result
+    @value
+  end
+end
+"""
+        chunks = self.chunk_builder.chunkify(ruby_code)
+        
+        assert len(chunks) > 0
+        assert any("Calculator" in chunk["content"] for chunk in chunks)
+        
+        # Check that metadata is properly generated
+        for chunk in chunks:
+            assert "metadata" in chunk
+            assert "chunk_size" in chunk["metadata"]
+            assert "start_line_no" in chunk["metadata"]
+            assert "end_line_no" in chunk["metadata"]
+
+    def test_ruby_module_chunking(self):
+        """Test chunking of Ruby modules."""
+        ruby_code = """
+module MathUtils
+  PI = 3.14159
+  
+  def self.square(x)
+    x * x
+  end
+  
+  def self.cube(x)
+    x * x * x
+  end
+  
+  module Helpers
+    def self.factorial(n)
+      return 1 if n <= 1
+      (1..n).inject(:*)
+    end
+  end
+end
+"""
+        chunks = self.chunk_builder.chunkify(ruby_code)
+        
+        assert len(chunks) > 0
+        assert any("MathUtils" in chunk["content"] for chunk in chunks)
+        assert any("Helpers" in chunk["content"] for chunk in chunks)
+
+    def test_ruby_singleton_methods(self):
+        """Test chunking of Ruby singleton methods."""
+        ruby_code = """
+class Person
+  attr_reader :name
+  
+  def initialize(name)
+    @name = name
+  end
+  
+  def self.create_anonymous
+    new("Anonymous")
+  end
+  
+  def greet
+    "Hello, I'm #{@name}"
+  end
+end
+
+person = Person.new("Alice")
+
+def person.special_greeting
+  "I'm special: #{@name}"
+end
+
+class << person
+  def another_special_method
+    "Another special method"
+  end
+end
+"""
+        chunks = self.chunk_builder.chunkify(ruby_code)
+        
+        assert len(chunks) > 0
+        content = " ".join(chunk["content"] for chunk in chunks)
+        assert "Person" in content
+        assert "create_anonymous" in content
+        assert "special_greeting" in content
+
+    def test_rails_style_controller(self):
+        """Test chunking of Rails-style controller code."""
+        rails_code = """
+class UsersController < ApplicationController
+  before_action :authenticate_user!
+  before_action :find_user, only: [:show, :edit, :update, :destroy]
+  
+  def index
+    @users = User.all.page(params[:page])
+    respond_to do |format|
+      format.html
+      format.json { render json: @users }
+    end
+  end
+  
+  def show
+    respond_to do |format|
+      format.html
+      format.json { render json: @user }
+    end
+  end
+  
+  def create
+    @user = User.new(user_params)
+    
+    if @user.save
+      redirect_to @user, notice: 'User was successfully created.'
+    else
+      render :new
+    end
+  end
+  
+  private
+  
+  def find_user
+    @user = User.find(params[:id])
+  end
+  
+  def user_params
+    params.require(:user).permit(:name, :email, :role)
+  end
+end
+"""
+        chunks = self.chunk_builder.chunkify(rails_code)
+        
+        assert len(chunks) > 0
+        content = " ".join(chunk["content"] for chunk in chunks)
+        assert "UsersController" in content
+        assert "ApplicationController" in content
+        assert "before_action" in content
+
+    def test_rails_style_model(self):
+        """Test chunking of Rails-style model code."""
+        rails_code = """
+class User < ApplicationRecord
+  include Authenticatable
+  extend FriendlyId
+  
+  friendly_id :name, use: :slugged
+  
+  has_many :posts, dependent: :destroy
+  has_many :comments, through: :posts
+  belongs_to :organization, optional: true
+  
+  validates :name, presence: true, length: { minimum: 2 }
+  validates :email, presence: true, uniqueness: true
+  
+  enum status: { active: 0, inactive: 1, suspended: 2 }
+  
+  scope :recent, -> { where('created_at > ?', 1.week.ago) }
+  scope :by_organization, ->(org) { where(organization: org) }
+  
+  def full_name
+    [first_name, last_name].compact.join(' ')
+  end
+  
+  def can_edit?(resource)
+    admin? || resource.user == self
+  end
+  
+  class << self
+    def find_by_email_or_username(identifier)
+      find_by(email: identifier) || find_by(username: identifier)
+    end
+    
+    def admin_users
+      where(role: 'admin')
+    end
+  end
+  
+  private
+  
+  def normalize_email
+    self.email = email.downcase.strip if email.present?
+  end
+end
+"""
+        chunks = self.chunk_builder.chunkify(rails_code)
+        
+        assert len(chunks) > 0
+        content = " ".join(chunk["content"] for chunk in chunks)
+        assert "User" in content
+        assert "ApplicationRecord" in content
+        assert "validates" in content
+        assert "has_many" in content
+
+    def test_ruby_block_syntax(self):
+        """Test chunking of Ruby code with various block syntaxes."""
+        ruby_code = """
+class DataProcessor
+  def process_data(items)
+    # Block with do..end
+    items.each do |item|
+      puts "Processing: #{item}"
+      process_item(item)
+    end
+    
+    # Block with curly braces
+    filtered = items.select { |item| item.valid? }
+    
+    # Method with block parameter
+    items.map(&:name).compact
+    
+    # Proc and lambda
+    calculator = proc { |x, y| x + y }
+    multiplier = lambda { |x, y| x * y }
+    
+    # Block with multiple parameters
+    items.each_with_index do |item, index|
+      puts "Item #{index}: #{item}"
+    end
+  end
+  
+  private
+  
+  def process_item(item)
+    item.process!
+  rescue StandardError => e
+    Rails.logger.error "Failed to process item: #{e.message}"
+  end
+end
+"""
+        chunks = self.chunk_builder.chunkify(ruby_code)
+        
+        assert len(chunks) > 0
+        content = " ".join(chunk["content"] for chunk in chunks)
+        assert "DataProcessor" in content
+        assert "process_data" in content
+        assert "each do" in content
+
+    def test_ruby_metaprogramming(self):
+        """Test chunking of Ruby metaprogramming constructs."""
+        ruby_code = """
+module Trackable
+  extend ActiveSupport::Concern
+  
+  included do
+    has_many :tracking_events, as: :trackable, dependent: :destroy
+    
+    after_create :track_creation
+    after_update :track_update
+  end
+  
+  class_methods do
+    def track_method(method_name)
+      alias_method "#{method_name}_without_tracking", method_name
+      
+      define_method method_name do |*args|
+        result = send("#{method_name}_without_tracking", *args)
+        track_event("#{method_name}_called")
+        result
+      end
+    end
+  end
+  
+  def track_event(event_name, data = {})
+    tracking_events.create!(
+      event_name: event_name,
+      event_data: data,
+      occurred_at: Time.current
+    )
+  end
+  
+  private
+  
+  def track_creation
+    track_event('created')
+  end
+  
+  def track_update
+    track_event('updated', changes: previous_changes)
+  end
+end
+
+class Product
+  include Trackable
+  
+  track_method :update_price
+  
+  def update_price(new_price)
+    self.price = new_price
+    save!
+  end
+end
+"""
+        chunks = self.chunk_builder.chunkify(ruby_code)
+        
+        assert len(chunks) > 0
+        content = " ".join(chunk["content"] for chunk in chunks)
+        assert "Trackable" in content
+        assert "ActiveSupport::Concern" in content
+        assert "class_methods" in content
+        assert "define_method" in content
+
+    def test_chunk_metadata_with_ruby_constructs(self):
+        """Test that chunk metadata properly captures Ruby constructs."""
+        ruby_code = """
+module TestModule
+  class TestClass
+    def test_method
+      puts "Hello from Ruby!"
+    end
+  end
+end
+"""
+        chunks = self.chunk_builder.chunkify(ruby_code, 
+                                            repo_level_metadata={"filepath": "test.rb"})
+        
+        assert len(chunks) > 0
+        
+        for chunk in chunks:
+            metadata = chunk["metadata"]
+            assert "filepath" in metadata
+            assert metadata["filepath"] == "test.rb"
+            assert "chunk_size" in metadata
+            assert "line_count" in metadata
+            assert "start_line_no" in metadata
+            assert "end_line_no" in metadata
+            assert "node_count" in metadata
+
+    def test_chunk_size_limits_with_ruby(self):
+        """Test that chunk size limits are respected with Ruby code."""
+        large_ruby_code = """
+class LargeClass
+  def method_one
+    puts "This is method one with some content"
+    x = 1 + 2 + 3 + 4 + 5
+    return x
+  end
+  
+  def method_two
+    puts "This is method two with different content"
+    y = 10 * 20 * 30
+    return y
+  end
+  
+  def method_three
+    puts "This is method three with more content"
+    z = "a" + "b" + "c" + "d"
+    return z
+  end
+end
+"""
+        # Use a small chunk size to force multiple chunks
+        small_config = {
+            "max_chunk_size": 50,  # Very small to force splitting
+            "language": "ruby",
+            "metadata_template": "default"
+        }
+        small_chunk_builder = ASTChunkBuilder(**small_config)
+        chunks = small_chunk_builder.chunkify(large_ruby_code)
+        
+        # Should create multiple chunks due to size limit
+        assert len(chunks) > 1
+        
+        # Each chunk should respect the size limit (approximately)
+        for chunk in chunks:
+            assert chunk["metadata"]["chunk_size"] <= 50 + 20  # Some tolerance for AST boundaries
+
+    def test_empty_ruby_code(self):
+        """Test handling of empty or minimal Ruby code."""
+        minimal_code = "# Just a comment"
+        chunks = self.chunk_builder.chunkify(minimal_code)
+        
+        # Should handle gracefully, might return empty or single chunk
+        assert isinstance(chunks, list)
+
+    def test_ruby_syntax_error_handling(self):
+        """Test that syntax errors are handled gracefully."""
+        # This is not valid Ruby syntax
+        invalid_ruby = """
+class BrokenClass
+  def broken_method
+    # Missing end statement
+  
+  def another_method
+    puts "This should not parse correctly"
+"""
+        
+        # Should not raise an exception, but might return unexpected results
+        try:
+            chunks = self.chunk_builder.chunkify(invalid_ruby)
+            assert isinstance(chunks, list)
+        except Exception as e:
+            # If an exception is raised, it should be handled gracefully
+            pytest.fail(f"Should handle syntax errors gracefully, but got: {e}")
+
+    def test_complex_ruby_inheritance(self):
+        """Test chunking of complex Ruby inheritance patterns."""
+        ruby_code = """
+class Animal
+  attr_accessor :name, :age
+  
+  def initialize(name, age)
+    @name = name
+    @age = age
+  end
+  
+  def speak
+    raise NotImplementedError, "Subclasses must implement speak method"
+  end
+end
+
+module Walkable
+  def walk
+    puts "#{name} is walking"
+  end
+end
+
+module Flyable
+  def fly
+    puts "#{name} is flying"
+  end
+end
+
+class Dog < Animal
+  include Walkable
+  
+  def speak
+    "Woof! I'm #{name}"
+  end
+  
+  def fetch
+    "#{name} is fetching the ball"
+  end
+end
+
+class Bird < Animal
+  include Walkable
+  include Flyable
+  
+  def speak
+    "Tweet! I'm #{name}"
+  end
+  
+  def migrate
+    fly
+    puts "#{name} is migrating south"
+  end
+end
+"""
+        chunks = self.chunk_builder.chunkify(ruby_code)
+        
+        assert len(chunks) > 0
+        content = " ".join(chunk["content"] for chunk in chunks)
+        assert "Animal" in content
+        assert "Walkable" in content
+        assert "Flyable" in content
+        assert "Dog" in content
+        assert "Bird" in content
+
+
+class TestRubyAncestorBuilding:
+    """Test the ancestor building functionality specifically for Ruby constructs."""
+    
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.config = {
+            "max_chunk_size": 500,  # Large enough to capture full constructs
+            "language": "ruby",
+            "metadata_template": "default"
+        }
+        self.chunk_builder = ASTChunkBuilder(**self.config)
+
+    def test_nested_class_ancestors(self):
+        """Test that nested Ruby classes build proper ancestor paths."""
+        ruby_code = """
+module Outer
+  class Middle
+    class Inner
+      def deep_method
+        puts "Deep inside nested classes"
+      end
+    end
+  end
+end
+"""
+        chunks = self.chunk_builder.chunkify(ruby_code)
+        
+        # Find the chunk containing the deep_method
+        method_chunk = None
+        for chunk in chunks:
+            if "deep_method" in chunk["content"]:
+                method_chunk = chunk
+                break
+        
+        assert method_chunk is not None
+        # The exact ancestor behavior will depend on the implementation
+        # but we should at least have the chunk content
+        assert "deep_method" in method_chunk["content"]
+
+    def test_module_and_class_mixing(self):
+        """Test ancestor building with mixed modules and classes."""
+        ruby_code = """
+module OuterModule
+  module InnerModule
+    class NestedClass
+      def target_method
+        "Found me!"
+      end
+    end
+  end
+end
+"""
+        chunks = self.chunk_builder.chunkify(ruby_code)
+        
+        assert len(chunks) > 0
+        # Verify the structure is preserved in chunks
+        content = " ".join(chunk["content"] for chunk in chunks)
+        assert "OuterModule" in content
+        assert "InnerModule" in content
+        assert "NestedClass" in content
+        assert "target_method" in content
+
+
+if __name__ == "__main__":
+    pytest.main([__file__])
\ No newline at end of file