decode 0.23.4 → 0.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d918d6104a7b51fdf463bc40d3c5108dcfbae329064cb25395a988cb45c6aba
-  data.tar.gz: 7d303793cff2638b2b6c5a0527ab3cb0cfa3a33a0c4c1340436e03f0d7804602
+  metadata.gz: 8caef896e4f0541d426216be2ee041cd78ef81642b677a420d9f89f77a719ae0
+  data.tar.gz: 26c7090e233385633a99ec80f906f6cc7f429dd3eb02fe0d24a87ab9019b2931
 SHA512:
-  metadata.gz: 4fa8f8c71fb84a01414399a3f214d0870ee220225d2059ddb4416cb00bd7e4425ddf4c81c6c5a02ade8d53d9462f0be1544b4dd514b3b57d9dd3e052225fe269
-  data.tar.gz: 81174c0ff895f8ade0f80ad31216bcfeb13080173728c186fba4d37843ca45c551438a5401d865d32bef97e8416b5ab4bebaa5983949f43b8e22d56591d139ce
+  metadata.gz: 9b3ef91c4974a9d9cad7b5918dd885d55838c4a0d1f0eb06e2584bcde500e6bc657ef2bb11c50b6963171336153ae76a8b8d2365ed5444895906b35272e4795f
+  data.tar.gz: 4c60126b5604f42b9c8f9e1f10d47ba264d52042a0365881df2957bf77ad0faf6a2f8a9fc7e05c77c430a8376a873b606d9e5112bddee194944323247108e139

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/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)

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

@@ -12,7 +12,17 @@ module Decode
 			class Call < Definition
 				# A block can sometimes be a container for other definitions.
 				def container?
-					@node&.block && @node.block.opening == "do"
+					case block = @node&.block
+					when nil
+						false
+					when Prism::BlockArgumentNode
+						false
+					when Prism::BlockNode
+						# Technically, all block nodes are containers, but we prefer to be opinionated about when we consider them containers:
+						block.opening == "do"
+					else
+						false
+					end
 				end
 				
 				# The short form of the class.
@@ -33,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/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,83 @@
+# 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
+		class Class < Wrapper
+			
+			def initialize(definition)
+				super
+				@generics = nil
+			end
+			
+			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,97 @@
+# 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
+		class Generator
+			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 = {}
+				
+				# 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
+								build_nested_declaration(definition, declarations, index)
+							end
+						end
+					end
+					
+					# Continue traversing children
+					descend.call
+				end
+				
+				# Write the RBS output
+				writer = ::RBS::Writer.new(out: output)
+				
+				unless declarations.empty?
+					writer.write(declarations.values)
+				end
+			end
+			
+			private
+			
+			# Build nested RBS declarations preserving the parent hierarchy
+			def build_nested_declaration(definition, declarations, index)
+				# Create the declaration for this definition using ||= to avoid duplicates
+				qualified_name = definition.qualified_name
+				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
+				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,209 @@
+# 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
+		class Method < Wrapper
+			
+			def initialize(definition)
+				super
+				@signatures = nil
+			end
+			
+			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,45 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "rbs"
+require_relative "wrapper"
+
+module Decode
+	module RBS
+		class Module < Wrapper
+			
+			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,11 @@
+# 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"

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/version.rb

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

data/readme.md

@@ -22,6 +22,14 @@ Please see the [project documentation](https://ioquatix.github.io/decode/) for m
 
 Please see the [project releases](https://ioquatix.github.io/decode/releases/index) for all releases.
 
+### v0.24.0
+
+  - [Introduce support for RBS signature generation.](https://ioquatix.github.io/decode/releases/index#introduce-support-for-rbs-signature-generation.)
+
+### v0.23.5
+
+  - Fix handling of `&block` arguments in call nodes.
+
 ### v0.23.4
 
   - Fix handling of definitions nested within `if`/`unless`/`elsif`/`else` blocks.

data/releases.md

@@ -1,5 +1,39 @@
 # 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.
+
 ## v0.23.4
 
   - Fix handling of definitions nested within `if`/`unless`/`elsif`/`else` blocks.

data.tar.gz.sig

@@ -1,4 +1,2 @@
-P�g����^�+�u���<
-�&�Z��0�;�*�݀�Zd6u��(�X��`P�TX��!�w���j�	��n���Œ�ܰ�njX�Vvׇ�D�����P��\�D�AP�5f����@��S1��_���@��w�s�$A3�!��,����3&M\h9q� ex��-W�+N�=��
-|��'����1d�YǡQ�d�{ί�LW}7��A���;*Py9��q�ߣ:=���v#���x.���`Y�7��W�GM����Mi+|uG���2ivf
-�?{�Sj�1�lT��T@""�u?��T�u���@�
+��x�H��cز�6��;��Z��nC�3����Ʌ#�@���sW��-��A����(ȧ�\�2�~�(�g��ϸwA�^��
+�����C]먩��f~:&t˴����H�=	���+�O/���J�R��.S��FDz��wZIڧ��H�?(jx&y߸�򂳮}M*���E��{��Qf<
��4Z�Ʉ���^���

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: decode
 version: !ruby/object:Gem::Version
-  version: 0.23.4
+  version: 0.24.0
 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