RBS Generate

Generate RBS (Ruby Signature) type definitions from Ruby source files.

Instructions

When generating RBS signatures, follow these steps:

1. Analyze the Ruby Source

Read and understand the Ruby source file:

• Identify all classes and modules
• Map method signatures (parameters, return values)
• Detect instance variables and their likely types
• Identify constants and their types
• Note inheritance and module inclusions

2. Infer Types

Use these strategies to infer types:

From method names:

• *? methods return bool
• to_s, name, title return String
• to_i, count, size, length return Integer
• to_a, *s (plurals) return Array
• to_h returns Hash

From default values:

• param = "" suggests String
• param = 0 suggests Integer
• param = [] suggests Array
• param = {} suggests Hash
• param = nil suggests optional type

From usage patterns:

• .each iteration suggests Enumerable
• << suggests Array or similar
• [] access suggests Array or Hash

From Ruby idioms:

• attr_reader :name with @name = "..." suggests String
• initialize parameters often match instance variable types

3. Generate RBS File

Create the .rbs file following conventions:

• Place in sig/ directory mirroring source structure
• Use proper RBS syntax for all declarations
• Include visibility modifiers (public, private)
• Add type parameters for generic classes
• Use union types when multiple types are possible

4. RBS Syntax Reference

# Class definition
class ClassName
  # Instance variables
  @name: String
  @count: Integer?  # nullable

  # Constants
  VERSION: String

  # Class methods
  def self.create: (String name) -> ClassName

  # Instance methods
  def initialize: (String name, ?Integer age) -> void
  def name: () -> String
  def process: (Array[String] items) -> Hash[Symbol, untyped]

  # Block parameters
  def each: () { (String) -> void } -> self

  # Private methods
  private
  def internal: () -> void
end

# Module definition
module Searchable
  def search: (String query) -> Array[self]
end

# Interface
interface _Printable
  def to_s: () -> String
end

5. Output Structure

sig/
├── lib/
│   ├── my_class.rbs
│   └── my_module.rbs
└── app/
    └── models/
        └── user.rbs

Example

Input Ruby file (lib/user.rb):

class User
  attr_reader :name, :email

  def initialize(name, email)
    @name = name
    @email = email
    @active = true
  end

  def active?
    @active
  end

  def deactivate!
    @active = false
  end

  def full_info
    "#{name} <#{email}>"
  end
end

Generated RBS (sig/lib/user.rbs):

class User
  @name: String
  @email: String
  @active: bool

  attr_reader name: String
  attr_reader email: String

  def initialize: (String name, String email) -> void
  def active?: () -> bool
  def deactivate!: () -> bool
  def full_info: () -> String
end

Additional Examples

For more complete examples, see:

• examples/user.rb - Full User class with constants and class methods
• examples/user.rbs - Complete RBS signature for User
• examples/collection.rb - Generic collection class
• examples/collection.rbs - RBS with type parameters