decode 0.23.5 → 0.24.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11a86571ec0cc705f2d0250c768572373ae0717a991a50f57b78cd148a0cd021
-  data.tar.gz: aa180f6bb19db4c6f75c372a3eb43a44067ff7b9a964aa332424fc19b2d85273
+  metadata.gz: 16fcc036ea4c0db950c8dccf9b8f7a8a8b646e4375d5aa51dae09aa119269916
+  data.tar.gz: 209ee8f76ba71de8f80df11d838f734d36867bc7bde266188731e07e16cfadd2
 SHA512:
-  metadata.gz: 8c78fd76970e57222c42100d8e910eedd71e1eeb3de399d06ef5e4c24e74a1acd2027a67bc9a6178bb93b19917fd2595d513ee1ee8729cfb8f6c0ca0b6458156
-  data.tar.gz: afb977b32a85cf2e44e59b437a54cb88b9ef454db994f595bb97ba3ca23ca24415bcdb8bb12a584378c05ec71e35bf1424f15eb7fa8e7b67e8460c00ceea3518
+  metadata.gz: 841791e39cb636b47ed5a2bd9f5974ab8fc77bccf1fb7ab932300aa0c32046afe47a42ebc562c3580bfc53363b89bc5afcb9e1af151f3c414dc367b4a940d02e
+  data.tar.gz: 173fa08e9dcac6fa0afdc73ccb9452afb95c4dccf00333e0209692628bb0336e80cd1eea65061458e301980726e94701d08e3e02fccaa30482b1faf97b49331d

data/agent.md

@@ -29,3 +29,11 @@ There are two types of mocking in sus: `receive` and `mock`. The `receive` match
 #### [Shared Test Behaviors and Fixtures](.context/sus/shared.md)
 
 Sus provides shared test contexts which can be used to define common behaviours or tests that can be reused across one or more test files.
+
+### types
+
+A simple human-readable and Ruby-parsable type library.
+
+#### [Usage](.context/types/usage.md)
+
+The Types gem provides abstract types for the Ruby programming language that can be used for documentation and evaluation purposes. It offers a simple and Ruby-compatible approach to type signature...

data/bake/decode/index.rb

@@ -13,10 +13,7 @@ end
 # Process the given source root and report on comment coverage.
 # @parameter root [String] The root path to index.
 def coverage(root)
-	paths = Dir.glob(File.join(root, "**/*"))
-	
-	index = Decode::Index.new
-	index.update(paths)
+	index = Decode::Index.for(root)
 	
 	documented = Set.new
 	missing = {}
@@ -71,10 +68,7 @@ end
 # Process the given source root and report on symbols.
 # @parameter root [String] The root path to index.
 def symbols(root)
-	paths = Dir.glob(File.join(root, "**/*"))
-	
-	index = Decode::Index.new
-	index.update(paths)
+	index = Decode::Index.for(root)
 	
 	index.trie.traverse do |path, node, descend|
 		level = path.size
@@ -91,10 +85,7 @@ end
 # Print documentation for all definitions.
 # @parameter root [String] The root path to index.
 def documentation(root)
-	paths = Dir.glob(File.join(root, "**/*"))
-	
-	index = Decode::Index.new
-	index.update(paths)
+	index = Decode::Index.for(root)
 	
 	index.definitions.each do |name, definition|
 		comments = definition.comments

data/bake/decode/rbs.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+def initialize(...)
+	super
+	
+	require "decode/rbs"
+end
+
+# Generate RBS declarations for the given source root.
+# @parameter root [String] The root path to index.
+def generate(root)
+	index = Decode::Index.for(root)
+	generator = Decode::RBS::Generator.new
+	generator.generate(index)
+end

data/lib/decode/comment/node.rb

@@ -61,7 +61,7 @@ module Decode
 			#
 			# @yields {|node, descend| descend.call}
 			# 	@parameter node [Node] The current node which is being traversed.
-			# 	@parameter descend [Proc | Nil] The recursive method for traversing children.
+			# 	@parameter descend [Proc] The recursive method for traversing children.
 			def traverse(&block)
 				descend = ->(node){node.traverse(&block)}
 				

data/lib/decode/comment/rbs.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require_relative "tag"
+
+module Decode
+	module Comment
+		# Represents an RBS type annotation following rbs-inline syntax.
+		#
+		# Examples:
+		# - `@rbs generic T` - Declares a generic type parameter for a class
+		# - `@rbs [T] () { () -> T } -> Task[T]` - Complete method type signature
+		#
+		class RBS < Tag
+			# Parse an RBS pragma from text.
+			# @parameter directive [String] The directive name (should be "rbs").
+			# @parameter text [String] The RBS type annotation text.
+			# @parameter lines [Array(String)] The remaining lines (not used for RBS).
+			# @parameter tags [Array(Tag)] The collection of tags.
+			# @parameter level [Integer] The indentation level.
+			def self.parse(directive, text, lines, tags, level = 0)
+				self.build(directive, text)
+			end
+			
+			# Build an RBS pragma from a directive and text.
+			# @parameter directive [String] The directive name.
+			# @parameter text [String] The RBS type annotation text.
+			def self.build(directive, text)
+				node = self.new(directive, text)
+				return node
+			end
+			
+			# Initialize a new RBS pragma.
+			# @parameter directive [String] The directive name.
+			# @parameter text [String] The RBS type annotation text.
+			def initialize(directive, text = nil)
+				super(directive)
+				@text = text&.strip
+			end
+			
+			# The RBS type annotation text.
+			# @attribute [String] The raw RBS text.
+			attr :text
+			
+			# Check if this is a generic type declaration.
+			# @returns [Boolean] True if this is a generic declaration.
+			def generic?
+				@text&.start_with?("generic ")
+			end
+			
+			# Extract the generic type parameter name.
+			# @returns [String | Nil] The generic type parameter name, or nil if not a generic.
+			def generic_parameter
+				if generic?
+					# Extract the parameter name from "generic T" or "generic T, U"
+					match = @text.match(/^generic\s+([A-Z][A-Za-z0-9_]*(?:\s*,\s*[A-Z][A-Za-z0-9_]*)*)/)
+					return match[1] if match
+				end
+			end
+			
+			# Check if this is a method type signature.
+			# @returns [Boolean] True if this is a method signature.
+			def method_signature?
+				@text && !generic?
+			end
+			
+			# Get the method type signature text.
+			# @returns [String | Nil] The method signature text, or nil if not a method signature.
+			def method_signature
+				method_signature? ? @text : nil
+			end
+		end
+	end
+end

data/lib/decode/comment/tags.rb

@@ -56,7 +56,7 @@ module Decode
 						else
 							# Ignore unknown directive.
 						end
-					
+						
 					# Or it's just text:
 					else
 						yield Text.new(line)

data/lib/decode/definition.rb

@@ -119,14 +119,14 @@ module Decode
 		# A short form of the definition.
 		# e.g. `def short_form`.
 		#
-		# @returns [String | nil]
+		# @returns [String | Nil]
 		def short_form
 		end
 		
 		# A long form of the definition.
 		# e.g. `def initialize(kind, name, comments, **options)`.
 		#
-		# @returns [String | nil]
+		# @returns [String | Nil]
 		def long_form
 			self.short_form
 		end
@@ -134,7 +134,7 @@ module Decode
 		# A long form which uses the qualified name if possible.
 		# Defaults to {long_form}.
 		#
-		# @returns [String | nil]
+		# @returns [String | Nil]
 		def qualified_form
 			self.long_form
 		end
@@ -148,7 +148,7 @@ module Decode
 		
 		# The full text of the definition.
 		#
-		# @returns [String | nil]
+		# @returns [String | Nil]
 		def text
 		end
 		

data/lib/decode/index.rb

@@ -11,6 +11,33 @@ require_relative "languages"
 module Decode
 	# Represents a list of definitions organised for quick lookup and lexical enumeration.
 	class Index
+		# Create and populate an index from the given paths.
+		# @parameter paths [Array(String)] The paths to index (files, directories, or glob patterns).
+		# @parameter languages [Languages] The languages to support in this index.
+		# @returns [Index] A new index populated with definitions from the given paths.
+		def self.for(*paths, languages: Languages.all)
+			# Resolve all paths to actual files:
+			resolved_paths = paths.flat_map do |path|
+				if File.directory?(path)
+					Dir.glob(File.join(path, "**/*"))
+				elsif File.file?(path)
+					[path]
+				else
+					# Handle glob patterns or non-existent paths:
+					Dir.glob(path)
+				end
+			end
+			
+			resolved_paths.sort!
+			resolved_paths.uniq!
+			
+			# Create and populate the index:
+			index = new(languages)
+			index.update(resolved_paths)
+			
+			return index
+		end
+		
 		# Initialize an empty index.
 		# @parameter languages [Languages] The languages to support in this index.
 		def initialize(languages = Languages.all)
@@ -30,10 +57,10 @@ module Decode
 		def inspect
 			"#<#{self.class} #{@definitions.size} definition(s)>"
 		end
-
+		
 		# Generate a string representation of the index.
 		alias to_s inspect
-
+		
 		# All supported languages for this index.
 		# @attribute [Languages] The languages this index can parse.
 		attr :languages

data/lib/decode/language/ruby/call.rb

@@ -43,7 +43,7 @@ module Decode
 					else
 						# For multiline calls, use the actual call name with arguments
 						if @node.arguments && @node.arguments.arguments.any?
-							argument_text = @node.arguments.arguments.map {|argument| argument.location.slice}.join(", ")
+							argument_text = @node.arguments.arguments.map{|argument| argument.location.slice}.join(", ")
 							"#{@node.name}(#{argument_text})"
 						else
 							@node.name.to_s

data/lib/decode/language/ruby/class.rb

@@ -56,7 +56,7 @@ module Decode
 				def nested_name
 					"class"
 				end
-
+				
 				# A singleton class is a container for other definitions.
 				# @returns [Boolean]
 				def container?

data/lib/decode/language/ruby/generic.rb

@@ -8,6 +8,7 @@ require_relative "parser"
 require_relative "code"
 
 require_relative "../generic"
+require_relative "../../comment/rbs"
 
 module Decode
 	module Language
@@ -16,6 +17,25 @@ module Decode
 			class Generic < Language::Generic
 				EXTENSIONS = [".rb", ".ru"]
 				
+				TAGS = Comment::Tags.build do |tags|
+					tags["attribute"] = Comment::Attribute
+					tags["parameter"] = Comment::Parameter
+					tags["option"] = Comment::Option
+					tags["yields"] = Comment::Yields
+					tags["returns"] = Comment::Returns
+					tags["raises"] = Comment::Raises
+					tags["throws"] = Comment::Throws
+					
+					tags["deprecated"] = Comment::Pragma
+					
+					tags["asynchronous"] = Comment::Pragma
+					
+					tags["public"] = Comment::Pragma
+					tags["private"] = Comment::Pragma
+					
+					tags["rbs"] = Comment::RBS
+				end
+				
 				# Get the parser for Ruby source code.
 				# @returns [Parser] The Ruby parser instance.
 				def parser

data/lib/decode/language/ruby/parser.rb

@@ -509,7 +509,7 @@ module Decode
 								# Start a new segment with these comments
 								yield current_segment if current_segment
 								current_segment = Segment.new(
-									preceding_comments.map {|comment| comment.location.slice.sub(/^#[\s\t]?/, "")},
+									preceding_comments.map{|comment| comment.location.slice.sub(/^#[\s\t]?/, "")},
 									@language,
 									statement
 								)

data/lib/decode/language/ruby/segment.rb

@@ -32,7 +32,7 @@ module Decode
 				end
 				
 				# The source code trailing the comments.
-				# @returns [String | nil]
+				# @returns [String | Nil]
 				def code
 					@expression.slice
 				end

data/lib/decode/rbs/class.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "rbs"
+require_relative "wrapper"
+require_relative "method"
+module Decode
+	module RBS
+		# Represents a Ruby class definition wrapper for RBS generation.
+		class Class < Wrapper
+			
+			# Initialize a new class wrapper.
+			# @parameter definition [Decode::Definition] The class definition to wrap.
+			def initialize(definition)
+				super
+				@generics = nil
+			end
+			
+			# Extract generic type parameters from the class definition.
+			# @returns [Array] The generic type parameters for this class.
+			def generics
+				@generics ||= extract_generics
+			end
+			
+			# Convert the class definition to RBS AST
+			def to_rbs_ast(method_definitions = [], index = nil)
+				name = simple_name_to_rbs(@definition.name)
+				comment = extract_comment(@definition)
+				
+				# Extract generics from RBS tags
+				type_params = generics.map do |generic|
+					::RBS::AST::TypeParam.new(
+						name: generic.to_sym,
+						variance: nil,
+						upper_bound: nil,
+						location: nil
+					)
+				end
+				
+				# Build method definitions
+				methods = method_definitions.map{|method_def| Method.new(method_def).to_rbs_ast(index)}.compact
+				
+				# Extract super class if present
+				super_class = if @definition.super_class
+					::RBS::AST::Declarations::Class::Super.new(
+						name: qualified_name_to_rbs(@definition.super_class),
+						args: [],
+						location: nil
+					)
+				end
+				
+				# Create the class declaration with generics
+				::RBS::AST::Declarations::Class.new(
+					name: name,
+					type_params: type_params,
+					super_class: super_class,
+					members: methods,
+					annotations: [],
+					location: nil,
+					comment: comment
+				)
+			end
+			
+			private
+			
+			def extract_generics
+				tags.select(&:generic?).map(&:generic_parameter)
+			end
+			
+			# Convert a simple name to RBS TypeName (not qualified)
+			def simple_name_to_rbs(name)
+				::RBS::TypeName.new(name: name.to_sym, namespace: ::RBS::Namespace.empty)
+			end
+			
+			# Convert a qualified name to RBS TypeName
+			def qualified_name_to_rbs(qualified_name)
+				parts = qualified_name.split("::")
+				name = parts.pop
+				namespace = ::RBS::Namespace.new(path: parts.map(&:to_sym), absolute: true)
+				
+				::RBS::TypeName.new(name: name.to_sym, namespace: namespace)
+			end
+			
+		end
+	end
+end

data/lib/decode/rbs/generator.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "rbs"
+require_relative "../index"
+require_relative "class"
+require_relative "module"
+
+module Decode
+	module RBS
+		# Represents a generator for RBS type declarations.
+		class Generator
+			# Initialize a new RBS generator.
+			# Sets up the RBS environment for type resolution.
+			def initialize
+				# Set up RBS environment for type resolution
+				@loader = ::RBS::EnvironmentLoader.new()
+				@environment = ::RBS::Environment.from_loader(@loader).resolve_type_names
+			end
+			
+			# Generate RBS declarations for the given index.
+			# @parameter index [Decode::Index] The index containing definitions to generate RBS for.
+			# @parameter output [IO] The output stream to write to.
+			def generate(index, output: $stdout)
+				# Build nested RBS AST structure using a hash for proper ||= behavior
+				declarations = {}
+				roots = []
+				
+				# Efficiently traverse the trie to find containers and their methods
+				index.trie.traverse do |lexical_path, node, descend|
+					# Process container definitions at this node
+					if node.values
+						containers = node.values.select {|definition| definition.container? && definition.public?}
+						containers.each do |definition|
+							case definition
+							when Decode::Language::Ruby::Class, Decode::Language::Ruby::Module
+								if declaration = build_nested_declaration(definition, declarations, index)
+									roots << declaration
+								end
+							end
+						end
+					end
+					
+					# Continue traversing children
+					descend.call
+				end
+				
+				# Write the RBS output
+				writer = ::RBS::Writer.new(out: output)
+				
+				unless roots.empty?
+					writer.write(roots)
+				end
+			end
+			
+			private
+			
+			# Build nested RBS declarations preserving the parent hierarchy.
+			# @returns [::RBS::AST::Declarations::Class | ::RBS::AST::Declarations::Module] If the definition has no parent, returns the declaration.
+			# @returns [Nil] If the definition has a parent, adds to parent's members.
+			def build_nested_declaration(definition, declarations, index)
+				# Create the declaration for this definition using ||= to avoid duplicates
+				qualified_name = definition.qualified_name
+				declaration = (declarations[qualified_name] ||= definition_to_rbs(definition, index))
+				
+				# Add this declaration to its parent's members if it has a parent
+				if definition.parent
+					parent_qualified_name = definition.parent.qualified_name
+					parent_container = declarations[parent_qualified_name]
+					
+					# Only add if not already present
+					unless parent_container.members.any?{|member| member.respond_to?(:name) && member.name.name == definition.name.to_sym}
+						parent_container.members << declarations[qualified_name]
+					end
+					
+					return nil
+				else
+					return declaration
+				end
+			end
+			
+			# Convert a definition to RBS AST
+			def definition_to_rbs(definition, index)
+				case definition
+				when Decode::Language::Ruby::Class
+					Class.new(definition).to_rbs_ast(get_methods_for_definition(definition, index), index)
+				when Decode::Language::Ruby::Module  
+					Module.new(definition).to_rbs_ast(get_methods_for_definition(definition, index), index)
+				end
+			end
+			
+			# Get methods for a given definition efficiently using trie lookup
+			def get_methods_for_definition(definition, index)
+				# Use the trie to efficiently find methods for this definition
+				if node = index.trie.lookup(definition.full_path)
+					node.children.flat_map do |name, child|
+						child.values.select{|symbol| symbol.is_a?(Decode::Language::Ruby::Method) && symbol.public?}
+					end
+				else
+					[]
+				end
+			end
+		end
+	end
+end 

data/lib/decode/rbs/method.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "rbs"
+require "console"
+require "types"
+require_relative "wrapper"
+
+module Decode
+	module RBS
+		# Represents a Ruby method definition wrapper for RBS generation.
+		class Method < Wrapper
+			
+			# Initialize a new method wrapper.
+			# @parameter definition [Decode::Definition] The method definition to wrap.
+			def initialize(definition)
+				super
+				@signatures = nil
+			end
+			
+			# Extract method signatures from the method definition.
+			# @returns [Array] The extracted signatures for this method.
+			def signatures
+				@signatures ||= extract_signatures
+			end
+			
+			# Convert the method definition to RBS AST
+			def to_rbs_ast(index = nil)
+				method_name = @definition.name
+				comment = extract_comment(@definition)
+				
+				overloads = []
+				if signatures.any?
+					signatures.each do |signature_string|
+						method_type = ::RBS::Parser.parse_method_type(signature_string)
+						overloads << ::RBS::AST::Members::MethodDefinition::Overload.new(
+							method_type: method_type,
+							annotations: []
+						)
+					end
+				else
+					return_type = extract_return_type(@definition, index) || ::RBS::Parser.parse_type("untyped")
+					parameters = extract_parameters(@definition, index)
+					block_type = extract_block_type(@definition, index)
+					
+					method_type = ::RBS::MethodType.new(
+						type_params: [],
+						type: ::RBS::Types::Function.new(
+							required_positionals: parameters,
+							optional_positionals: [],
+							rest_positionals: nil,
+							trailing_positionals: [],
+							required_keywords: {},
+							optional_keywords: {},
+							rest_keywords: nil,
+							return_type: return_type
+						),
+						block: block_type,
+						location: nil
+					)
+					
+					overloads << ::RBS::AST::Members::MethodDefinition::Overload.new(
+						method_type: method_type,
+						annotations: []
+					)
+				end
+				
+				kind = @definition.receiver ? :singleton : :instance
+				
+				::RBS::AST::Members::MethodDefinition.new(
+					name: method_name.to_sym,
+					kind: kind,
+					overloads: overloads,
+					annotations: [],
+					location: nil,
+					comment: comment,
+					overloading: false,
+					visibility: :public
+				)
+			end
+			
+			private
+			
+			def extract_signatures
+				extract_tags.select(&:method_signature?).map(&:method_signature)
+			end
+			
+			# Extract return type from method documentation
+			def extract_return_type(definition, index)
+				# Look for @returns tags in the method's documentation
+				documentation = definition.documentation
+				
+				# Find @returns tag
+				returns_tag = documentation&.filter(Decode::Comment::Returns)&.first
+				
+				if returns_tag
+					# Parse the type from the tag
+					type_string = returns_tag.type.strip
+					parse_type_string(type_string)
+				else
+					# Infer return type based on method name patterns
+					infer_return_type(definition)
+				end
+			end
+			
+			# Extract parameter types from method documentation
+			def extract_parameters(definition, index)
+				documentation = definition.documentation
+				return [] unless documentation
+				
+				# Find @parameter tags
+				param_tags = documentation.filter(Decode::Comment::Parameter).to_a
+				return [] if param_tags.empty?
+				
+				param_tags.map do |tag|
+					name = tag.name
+					type_string = tag.type.strip
+					type = parse_type_string(type_string)
+					
+					::RBS::Types::Function::Param.new(
+						type: type,
+						name: name.to_sym
+					)
+				end
+			end
+			
+			# Extract block type from method documentation
+			def extract_block_type(definition, index)
+				documentation = definition.documentation
+				return nil unless documentation
+				
+				# Find @yields tags
+				yields_tag = documentation.filter(Decode::Comment::Yields).first
+				return nil unless yields_tag
+				
+				# Extract block parameters from nested @parameter tags
+				block_params = yields_tag.filter(Decode::Comment::Parameter).map do |param_tag|
+					name = param_tag.name
+					type_string = param_tag.type.strip
+					type = parse_type_string(type_string)
+					
+					::RBS::Types::Function::Param.new(
+						type: type,
+						name: name.to_sym
+					)
+				end
+				
+				# Parse the block signature to determine if it's required
+				# Check both the directive name and the block signature
+				block_signature = yields_tag.block
+				directive_name = yields_tag.directive
+				required = !directive_name.include?("?") && !block_signature.include?("?") && !block_signature.include?("optional")
+				
+				# Determine block return type (default to void if not specified)
+				block_return_type = ::RBS::Parser.parse_type("void")
+				
+				# Create the block function type
+				block_function = ::RBS::Types::Function.new(
+					required_positionals: block_params,
+					optional_positionals: [],
+					rest_positionals: nil,
+					trailing_positionals: [],
+					required_keywords: {},
+					optional_keywords: {},
+					rest_keywords: nil,
+					return_type: block_return_type
+				)
+				
+				# Create and return the block type
+				::RBS::Types::Block.new(
+					type: block_function,
+					required: required,
+					self_type: nil
+				)
+			end
+			
+			# Infer return type based on method patterns and heuristics
+			def infer_return_type(definition)
+				method_name = definition.name
+				method_name_str = method_name.to_s
+				
+				# Methods ending with ? are typically boolean
+				if method_name_str.end_with?("?")
+					return ::RBS::Parser.parse_type("bool")
+				end
+				
+				# Methods named initialize return void
+				if method_name == :initialize
+					return ::RBS::Parser.parse_type("void")
+				end
+				
+				# Methods with names that suggest they return self
+				if method_name_str.match?(/^(add|append|prepend|push|<<|concat|merge!|sort!|reverse!|clear|delete|remove)/)
+					return ::RBS::Parser.parse_type("self")
+				end
+				
+				# Default to untyped
+				::RBS::Parser.parse_type("untyped")
+			end
+			
+			# Parse a type string and convert it to RBS type
+			def parse_type_string(type_string)
+				type = Types.parse(type_string)
+				return ::RBS::Parser.parse_type(type.to_rbs)
+			rescue => error
+				Console.warn(self, "Failed to parse type string: #{type_string}", error)
+				return ::RBS::Parser.parse_type("untyped")
+			end
+			
+		end
+	end
+end

data/lib/decode/rbs/module.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "rbs"
+require_relative "wrapper"
+
+module Decode
+	module RBS
+		# Represents a Ruby module definition wrapper for RBS generation.
+		class Module < Wrapper
+			
+			# Initialize a new module wrapper.
+			# @parameter definition [Decode::Definition] The module definition to wrap.
+			def initialize(definition)
+				super
+			end
+			
+			# Convert the module definition to RBS AST
+			def to_rbs_ast(method_definitions = [], index = nil)
+				name = simple_name_to_rbs(@definition.name)
+				comment = extract_comment(@definition)
+				
+				# Build method definitions
+				methods = method_definitions.map{|method_def| Method.new(method_def).to_rbs_ast(index)}.compact
+				
+				::RBS::AST::Declarations::Module.new(
+					name: name,
+					type_params: [],
+					self_types: [],
+					members: methods,
+					annotations: [],
+					location: nil,
+					comment: comment
+				)
+			end
+			
+			private
+			
+			# Convert a simple name to RBS TypeName (not qualified)
+			def simple_name_to_rbs(name)
+				::RBS::TypeName.new(name: name.to_sym, namespace: ::RBS::Namespace.empty)
+			end
+			
+		end
+	end
+end 

data/lib/decode/rbs/wrapper.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "rbs"
+
+module Decode
+	module RBS
+		# Base wrapper class for RBS generation from definitions.
+		class Wrapper
+			# Initialize the wrapper instance variables.
+			# @parameter definition [Definition] The definition to wrap.
+			def initialize(definition)
+				@definition = definition
+				@tags = nil
+			end
+			
+			# Extract RBS tags from the definition's documentation.
+			# @returns [Array<Comment::RBS>] The RBS tags found in the documentation.
+			def tags
+				@tags ||= extract_tags
+			end
+			
+			private
+			
+			# Extract RBS tags from the definition's documentation.
+			# @returns [Array<Comment::RBS>] The RBS tags found in the documentation.
+			def extract_tags
+				@definition.documentation&.children&.select do |child|
+					child.is_a?(Comment::RBS)
+				end || []
+			end
+			
+			# Extract comment from definition documentation.
+			# @parameter definition [Definition] The definition to extract comment from (defaults to @definition).
+			# @returns [RBS::AST::Comment, nil] The extracted comment or nil if no documentation.
+			def extract_comment(definition = @definition)
+				documentation = definition.documentation
+				return nil unless documentation
+				
+				# Extract the main description text (non-tag content)
+				comment_lines = []
+				
+				documentation.children&.each do |child|
+					if child.is_a?(Decode::Comment::Text)
+						comment_lines << child.line.strip
+					elsif !child.is_a?(Decode::Comment::Tag)
+						# Handle other text-like nodes
+						comment_lines << child.to_s.strip if child.respond_to?(:to_s)
+					end
+				end
+				
+				# Join lines with newlines to preserve markdown formatting
+				unless comment_lines.empty?
+					comment_text = comment_lines.join("\n").strip
+					return ::RBS::AST::Comment.new(string: comment_text, location: nil) unless comment_text.empty?
+				end
+				
+				nil
+			end
+		end
+	end
+end 

data/lib/decode/rbs.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "rbs"
+require_relative "rbs/wrapper"
+require_relative "rbs/class"
+require_relative "rbs/method"
+require_relative "rbs/module"
+require_relative "rbs/generator"
+
+module Decode
+	# RBS generation functionality for Ruby type signatures.
+	module RBS
+	end
+end

data/lib/decode/segment.rb

@@ -29,7 +29,7 @@ module Decode
 		attr :language
 		
 		# An interface for accsssing the documentation of the definition.
-		# @returns [Documentation | nil] A {Documentation} instance if this definition has comments.
+		# @returns [Documentation | Nil] A {Documentation} instance if this definition has comments.
 		def documentation
 			if @comments&.any?
 				@documentation ||= Documentation.new(@comments, @language)
@@ -37,7 +37,7 @@ module Decode
 		end
 		
 		# The source code trailing the comments.
-		# @returns [String | nil]
+		# @returns [String | Nil]
 		def code
 		end
 	end

data/lib/decode/trie.rb

@@ -21,10 +21,10 @@ module Decode
 			def inspect
 				"#<#{self.class} #{@children.size} children>"
 			end
-
+			
 			# Generate a string representation of the node.
 			alias to_s inspect
-
+			
 			# A mutable array of all values that terminate at this node.
 			# @attribute [Array | Nil] The values stored at this node, or nil if no values.
 			attr_accessor :values

data/lib/decode/version.rb

@@ -4,5 +4,5 @@
 # Copyright, 2020-2025, by Samuel Williams.
 
 module Decode
-	VERSION = "0.23.5"
+	VERSION = "0.24.1"
 end

data/readme.md

@@ -2,7 +2,7 @@
 
 A Ruby code analysis tool and documentation generator.
 
-[![Development Status](https://github.com/ioquatix/decode/workflows/Test/badge.svg)](https://github.com/ioquatix/decode/actions?workflow=Test)
+[![Development Status](https://github.com/socketry/decode/workflows/Test/badge.svg)](https://github.com/socketry/decode/actions?workflow=Test)
 
 ## Motivation
 
@@ -10,17 +10,21 @@ As part of my effort to build [better project documentation](https://github.com/
 
 ## Usage
 
-Please see the [project documentation](https://ioquatix.github.io/decode/) for more details.
+Please see the [project documentation](https://socketry.github.io/decode/) for more details.
 
-  - [Getting Started](https://ioquatix.github.io/decode/guides/getting-started/index) - This guide explains how to use `decode` for source code analysis.
+  - [Getting Started](https://socketry.github.io/decode/guides/getting-started/index) - This guide explains how to use `decode` for source code analysis.
 
-  - [Code Coverage](https://ioquatix.github.io/decode/guides/code-coverage/index) - This guide explains how to compute documentation code coverage.
+  - [Code Coverage](https://socketry.github.io/decode/guides/code-coverage/index) - This guide explains how to compute documentation code coverage.
 
-  - [Extract Symbols](https://ioquatix.github.io/decode/guides/extract-symbols/index) - This example demonstrates how to extract symbols using the index. An instance of <code class="language-ruby">Decode::Index</code> is used for loading symbols from source code files. These symbols are available as a flat list and as a trie structure. You can look up specific symbols using a reference using <code class="language-ruby">Decode::Index\#lookup</code>.
+  - [Extract Symbols](https://socketry.github.io/decode/guides/extract-symbols/index) - This example demonstrates how to extract symbols using the index. An instance of <code class="language-ruby">Decode::Index</code> is used for loading symbols from source code files. These symbols are available as a flat list and as a trie structure. You can look up specific symbols using a reference using <code class="language-ruby">Decode::Index\#lookup</code>.
 
 ## Releases
 
-Please see the [project releases](https://ioquatix.github.io/decode/releases/index) for all releases.
+Please see the [project releases](https://socketry.github.io/decode/releases/index) for all releases.
+
+### v0.24.0
+
+  - [Introduce support for RBS signature generation](https://socketry.github.io/decode/releases/index#introduce-support-for-rbs-signature-generation)
 
 ### v0.23.5
 

data/releases.md

@@ -1,5 +1,35 @@
 # Releases
 
+## v0.24.0
+
+### Introduce support for RBS signature generation
+
+Decode now supports generating RBS type signatures from Ruby source code, making it easier to add type annotations to existing Ruby projects. The RBS generator analyzes your Ruby code and documentation to produce type signatures that can be used with tools like Steep, TypeProf, and other RBS-compatible type checkers.
+
+To generate RBS signatures for your Ruby code, use the provided bake task:
+
+``` bash
+-- Generate RBS signatures for the current directory
+$ bundle exec bake decode:rbs:generate .
+
+-- Generate RBS signatures for a specific directory
+$ bundle exec bake decode:rbs:generate lib/
+```
+
+The generator will output RBS declarations to stdout, which you can redirect to a file:
+
+``` bash
+-- Save RBS signatures to a file
+$ bundle exec bake decode:rbs:generate lib/ > sig/generated.rbs
+```
+
+The RBS generator produces type signatures for:
+
+  - **Classes and modules** with their inheritance relationships.
+  - **Method signatures** with parameter and return types, or explicitly provide `@rbs` method signatures.
+  - **Generic type parameters** from `@rbs generic` documentation tags.
+  - **Documentation comments** as RBS comments.
+
 ## v0.23.5
 
   - Fix handling of `&block` arguments in call nodes.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: decode
 version: !ruby/object:Gem::Version
-  version: 0.23.5
+  version: 0.24.1
 platform: ruby
 authors:
 - Samuel Williams
@@ -52,12 +52,41 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rbs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - agent.md
 - bake/decode/index.rb
+- bake/decode/rbs.rb
 - context/coverage.md
 - context/getting-started.md
 - context/ruby-documentation.md
@@ -68,6 +97,7 @@ files:
 - lib/decode/comment/parameter.rb
 - lib/decode/comment/pragma.rb
 - lib/decode/comment/raises.rb
+- lib/decode/comment/rbs.rb
 - lib/decode/comment/returns.rb
 - lib/decode/comment/tag.rb
 - lib/decode/comment/tags.rb
@@ -98,6 +128,12 @@ files:
 - lib/decode/language/ruby/segment.rb
 - lib/decode/languages.rb
 - lib/decode/location.rb
+- lib/decode/rbs.rb
+- lib/decode/rbs/class.rb
+- lib/decode/rbs/generator.rb
+- lib/decode/rbs/method.rb
+- lib/decode/rbs/module.rb
+- lib/decode/rbs/wrapper.rb
 - lib/decode/scope.rb
 - lib/decode/segment.rb
 - lib/decode/source.rb
@@ -109,13 +145,13 @@ files:
 - license.md
 - readme.md
 - releases.md
-homepage: https://github.com/ioquatix/decode
+homepage: https://github.com/socketry/decode
 licenses:
 - MIT
 metadata:
-  documentation_uri: https://ioquatix.github.io/decode/
-  funding_uri: https://github.com/sponsors/ioquatix/
-  source_code_uri: https://github.com/ioquatix/decode.git
+  documentation_uri: https://socketry.github.io/decode/
+  funding_uri: https://github.com/sponsors/socketry/
+  source_code_uri: https://github.com/socketry/decode.git
 rdoc_options: []
 require_paths:
 - lib