decode 0.24.3 → 0.24.4

data/lib/decode/rbs/class.rb

@@ -19,15 +19,15 @@ module Decode
 			end
 			
 			# Extract generic type parameters from the class definition.
-			# @returns [Array] The generic type parameters for this class.
+			# @returns [Array[Symbol]] 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)
+			def to_rbs_ast(method_definitions = [], constant_definitions = [], attribute_definitions = [], index = nil)
 				name = simple_name_to_rbs(@definition.name)
-				comment = extract_comment(@definition)
+				comment = self.comment
 				
 				# Extract generics from RBS tags
 				type_params = generics.map do |generic|
@@ -39,24 +39,30 @@ module Decode
 					)
 				end
 				
-				# Build method definitions
+				# Build method definitions:
 				methods = method_definitions.map{|method_def| Method.new(method_def).to_rbs_ast(index)}.compact
 				
-				# Extract super class if present
+				# Build constant definitions:
+				constants = constant_definitions.map{|const_def| build_constant_rbs(const_def)}.compact
+				
+				# Build attribute definitions and infer instance variable types:
+				attributes, instance_variables = build_attributes_rbs(attribute_definitions)
+				
+				# 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
-					)
+								name: qualified_name_to_rbs(@definition.super_class),
+								args: [],
+								location: nil
+							)
 				end
 				
-				# Create the class declaration with generics
+				# Create the class declaration with generics:
 				::RBS::AST::Declarations::Class.new(
 					name: name,
 					type_params: type_params,
 					super_class: super_class,
-					members: methods,
+					members: constants + attributes + instance_variables + methods,
 					annotations: [],
 					location: nil,
 					comment: comment
@@ -69,18 +75,89 @@ module Decode
 				tags.select(&:generic?).map(&:generic_parameter)
 			end
 			
-			# Convert a simple name to RBS TypeName (not qualified)
+			# Build a constant RBS declaration.
+			def build_constant_rbs(constant_definition)
+				# Look for @constant tags in the constant's documentation:
+				documentation = constant_definition.documentation
+				constant_tags = documentation&.filter(Decode::Comment::Constant)&.to_a
+				
+				if constant_tags&.any?
+					type_string = constant_tags.first.type.strip
+					type = ::Decode::RBS::Type.parse(type_string)
+					
+					::RBS::AST::Declarations::Constant.new(
+						name: constant_definition.name.to_sym,
+						type: type,
+						location: nil,
+						comment: nil
+					)
+				end
+			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
 			
+			# Build attribute RBS declarations and infer instance variable types.
+			# @parameter attribute_definitions [Array] Array of Attribute definition objects
+			# @returns [Array] A tuple of [attribute_declarations, instance_variable_declarations]
+			def build_attributes_rbs(attribute_definitions)
+				attributes = []
+				instance_variables = []
+				
+				# Create a mapping from attribute names to their types:
+				attribute_types = {}
+				
+				attribute_definitions.each do |attr_def|
+					# Extract @attribute type annotation from documentation:
+					documentation = attr_def.documentation
+					attribute_tags = documentation&.filter(Decode::Comment::Attribute)&.to_a
+					
+					if attribute_tags&.any?
+						type_string = attribute_tags.first.type.strip
+						type = ::Decode::RBS::Type.parse(type_string)
+						
+						attribute_types[attr_def.name] = type
+						
+						# Generate attr_reader RBS declaration:
+						attributes << ::RBS::AST::Members::AttrReader.new(
+							name: attr_def.name.to_sym,
+							type: type,
+							ivar_name: :"@#{attr_def.name}",
+							kind: :instance,
+							annotations: [],
+							location: nil,
+							comment: nil
+						)
+						
+						# Generate instance variable declaration:
+						instance_variables << ::RBS::AST::Members::InstanceVariable.new(
+							name: :"@#{attr_def.name}",
+							type: type,
+							location: nil,
+							comment: nil
+						)
+					end
+				end
+				
+				[attributes, instance_variables]
+			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)
+				# For simple names (no ::), create relative references within current namespace:
+				if parts.empty?
+					::RBS::TypeName.new(name: name.to_sym, namespace: ::RBS::Namespace.empty)
+				else
+					# For qualified names within the same root namespace, use relative references.
+					# This handles cases like `Comment::Node`, `Language::Generic` within `Decode` module.
+					namespace = ::RBS::Namespace.new(path: parts.map(&:to_sym), absolute: false)
+					::RBS::TypeName.new(name: name.to_sym, namespace: namespace)
+				end
 			end
 			
 		end

data/lib/decode/rbs/generator.rb

@@ -14,19 +14,30 @@ module Decode
 		class Generator
 			# Initialize a new RBS generator.
 			# Sets up the RBS environment for type resolution.
-			def initialize
+			# @parameter include_private [bool] Whether to include private methods in RBS output.
+			def initialize(include_private: false)
 				# Set up RBS environment for type resolution
 				@loader = ::RBS::EnvironmentLoader.new()
 				@environment = ::RBS::Environment.from_loader(@loader).resolve_type_names
+				@include_private = include_private
 			end
 			
+			# @attribute [::RBS::EnvironmentLoader] The RBS environment loader.
+			attr :loader
+			
+			# @attribute [::RBS::Environment] The resolved RBS environment.
+			attr :environment
+			
+			# @attribute [bool] Whether to include private methods.
+			attr :include_private
+			
 			# 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 = {}
+				declarations = {} #: Hash[Array[Symbol], untyped]
+				roots = {} #: Hash[Array[Symbol], untyped]
 				
 				# Efficiently traverse the trie to find containers and their methods
 				index.trie.traverse do |lexical_path, node, descend|
@@ -58,8 +69,10 @@ module Decode
 			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.
+			# @parameter definition [Definition] The definition to build RBS for.
+			# @parameter declarations [Hash] The declarations hash to store results.
+			# @parameter index [Index] The index containing all definitions.
+			# @returns [untyped?] If the definition has no parent, returns the declaration, otherwise nil.
 			def build_nested_declaration(definition, declarations, index)
 				# Create the declaration for this definition using ||= to avoid duplicates
 				qualified_name = definition.qualified_name
@@ -81,22 +94,65 @@ module Decode
 				end
 			end
 			
-			# Convert a definition to RBS AST
+			# Convert a definition to RBS AST.
+			# @parameter definition [Definition] The definition to convert.
+			# @parameter index [Index] The index containing all definitions.
+			# @returns [untyped] The RBS AST declaration.
 			def definition_to_rbs(definition, index)
+				methods = get_methods_for_definition(definition, index)
+				constants = get_constants_for_definition(definition, index)
+				attributes = get_attributes_for_definition(definition, index)
+				
 				case definition
 				when Decode::Language::Ruby::Class
-					Class.new(definition).to_rbs_ast(get_methods_for_definition(definition, index), index)
+					Class.new(definition).to_rbs_ast(methods, constants, attributes, index)
 				when Decode::Language::Ruby::Module  
-					Module.new(definition).to_rbs_ast(get_methods_for_definition(definition, index), index)
+					Module.new(definition).to_rbs_ast(methods, constants, attributes, index)
 				end
 			end
 			
-			# Get methods for a given definition efficiently using trie lookup
+			# Get methods for a given definition efficiently using trie lookup.
+			# @parameter definition [Definition] The definition to get methods for.
+			# @parameter index [Index] The index containing all definitions.
+			# @returns [Array] Array of method definitions.
 			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?}
+						child.values.select do |symbol| 
+							symbol.is_a?(Decode::Language::Ruby::Method) && 
+							(symbol.public? || symbol.protected? || (@include_private && symbol.private?))
+						end
+					end
+				else
+					[]
+				end
+			end
+			
+			# Get constants for a given definition efficiently using trie lookup.
+			# @parameter definition [Definition] The definition to get constants for.
+			# @parameter index [Index] The index containing all definitions.
+			# @returns [Array] Array of constant definitions.
+			def get_constants_for_definition(definition, index)
+				# Use the trie to efficiently find constants 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::Constant)}
+					end
+				else
+					[]
+				end
+			end
+			
+			# Get attributes for a given definition efficiently using trie lookup.
+			# @parameter definition [Definition] The definition to get attributes for.
+			# @parameter index [Index] The index containing all definitions.
+			# @returns [Array] Array of attribute definitions.
+			def get_attributes_for_definition(definition, index)
+				# Use the trie to efficiently find attributes 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::Attribute)}
 					end
 				else
 					[]
@@ -104,4 +160,4 @@ module Decode
 			end
 		end
 	end
-end 
+end