decode 0.22.0 → 0.23.0

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

@@ -3,26 +3,34 @@
 # Released under the MIT License.
 # Copyright, 2020-2024, by Samuel Williams.
 
-require_relative 'definition'
+require_relative "definition"
 
 module Decode
 	module Language
 		module Ruby
 			# A Ruby-specific class.
 			class Class < Definition
+				# Initialize a new class definition.
+				# @parameter arguments [Array] The definition arguments.
+				# @parameter super_class [String] The super class name.
+				# @parameter options [Hash] Additional options.
+				def initialize(*arguments, super_class: nil, **options)
+					super(*arguments, **options)
+					
+					@super_class = super_class
+				end
+				
+				attr :super_class
+				
 				# A class is a container for other definitions.
 				def container?
 					true
 				end
 				
-				def nested_name
-					"::#{name}"
-				end
-				
 				# The short form of the class.
 				# e.g. `class Animal`.
 				def short_form
-					"class #{path_name.last}"
+					"class #{self.name}"
 				end
 				
 				# The long form of the class.
@@ -35,25 +43,16 @@ module Decode
 					end
 				end
 				
-				def super_class
-					if super_node = @node.children[1]
-						super_node.location.expression.source
-					end
-				end
-				
 				# The fully qualified name of the class.
 				# e.g. `class ::Barnyard::Dog`.
 				def qualified_form
 					"class #{self.qualified_name}"
 				end
-				
-				def path_name
-					@name.to_s.split('::').map(&:to_sym)
-				end
 			end
 			
 			# A Ruby-specific singleton class.
 			class Singleton < Definition
+				# Generate a nested name for the singleton class.
 				def nested_name
 					"::class"
 				end
@@ -73,35 +72,19 @@ module Decode
 				# The short form of the class.
 				# e.g. `class << self`.
 				def short_form
-					"class << #{@name}"
+					"class << #{self.name}"
 				end
 				
 				# The long form is the same as the short form.
 				alias long_form short_form
-
-				def path_name
-					[:class]
-				end
-
-				# The lexical scope as an array of names.
-				# e.g. `[:Decode, :Definition]`
-				# @returns [Array]
-				def path
-					if @path
-						# Cached version:
-						@path
-					else
-						@path = [*self.absolute_path, *self.path_name]
-					end
-				end
-
+				
 				private
-
+				
 				def absolute_path
 					if @parent
 						@parent.path
 					else
-						@name.to_s.split('::').map(&:to_sym)
+						@name.to_s.split("::").map(&:to_sym)
 					end
 				end
 			end

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

@@ -3,19 +3,24 @@
 # Released under the MIT License.
 # Copyright, 2020-2024, by Samuel Williams.
 
-require_relative 'definition'
-require_relative '../../syntax/link'
+require_relative "definition"
+require_relative "../../syntax/link"
 
-require 'parser/current'
+require "prism"
 
 module Decode
 	module Language
 		module Ruby
 			# A Ruby-specific block of code.
 			class Code
+				# Initialize a new code block.
+				# @parameter text [String] The code text.
+				# @parameter index [Index] The index to use.
+				# @parameter relative_to [Definition] The definition this code is relative to.
+				# @parameter language [Language] The language of the code.
 				def initialize(text, index, relative_to: nil, language: relative_to&.language)
 					@text = text
-					@root = ::Parser::CurrentRuby.parse(text)
+					@root = ::Prism.parse(text)
 					@index = index
 					@relative_to = relative_to
 					@language = language
@@ -25,9 +30,11 @@ module Decode
 				
 				attr :language
 				
+				# Extract definitions from the code.
+				# @parameter into [Array] The array to extract definitions into.
 				def extract(into = [])
 					if @index
-						traverse(@root, into)
+						traverse(@root.value, into)
 					end
 					
 					return into
@@ -37,29 +44,34 @@ module Decode
 				
 				def traverse(node, into)
 					case node&.type
-					when :send
+					when :program_node
+						traverse(node.statements, into)
+					when :call_node
 						if reference = Reference.from_const(node, @language)
 							if definition = @index.lookup(reference, relative_to: @relative_to)
-								expression = node.location.selector
-								range = expression.begin_pos...expression.end_pos
+								# Use message_loc for the method name, not the entire call
+								expression = node.message_loc
+								range = expression.start_offset...expression.end_offset
 								into << Syntax::Link.new(range, definition)
 							end
 						end
 						
 						# Extract constants from arguments:
-						children = node.children[2..-1].each do |node|
-							traverse(node, into)
+						if node.arguments
+							node.arguments.arguments.each do |arg_node|
+								traverse(arg_node, into)
+							end
 						end
-					when :const
+					when :constant_read_node
 						if reference = Reference.from_const(node, @language)
 							if definition = @index.lookup(reference, relative_to: @relative_to)
-								expression = node.location.name
-								range = expression.begin_pos...expression.end_pos
+								expression = node.location
+								range = expression.start_offset...expression.end_offset
 								into << Syntax::Link.new(range, definition)
 							end
 						end
-					when :begin
-						node.children.each do |child|
+					when :statements_node
+						node.body.each do |child|
 							traverse(child, into)
 						end
 					end

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

@@ -3,7 +3,7 @@
 # Released under the MIT License.
 # Copyright, 2020-2024, by Samuel Williams.
 
-require_relative 'definition'
+require_relative "definition"
 
 module Decode
 	module Language
@@ -13,9 +13,10 @@ module Decode
 				# The short form of the constant.
 				# e.g. `NAME`.
 				def short_form
-					@node.location.name.source
+					@node.name.to_s
 				end
 				
+				# Generate a nested name for the constant.
 				def nested_name
 					"::#{@name}"
 				end
@@ -23,12 +24,12 @@ module Decode
 				# The long form of the constant.
 				# e.g. `NAME = "Alice"`.
 				def long_form
-					if @node.location.line == @node.location.last_line
-						@node.location.expression.source
-					elsif @node.children[2].type == :array
-						"#{@name} = [...]"
-					elsif @node.children[2].type == :hash
-						"#{@name} = {...}"
+					if @node.location.start_line == @node.location.end_line
+						@node.location.slice
+					elsif @node.value&.type == :array_node
+						"#{@node.name} = [...]"
+					elsif @node.value&.type == :hash_node
+						"#{@node.name} = {...}"
 					else
 						self.short_form
 					end

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

@@ -3,60 +3,68 @@
 # Released under the MIT License.
 # Copyright, 2020-2024, by Samuel Williams.
 
-require_relative '../../definition'
+require_relative "../../definition"
 
 module Decode
 	module Language
 		module Ruby
-			# A Ruby-specific definition.
+			# Represents a Ruby-specific definition extracted from source code.
 			class Definition < Decode::Definition
 				# Initialize the definition from the syntax tree node.
-				def initialize(node, *arguments, visibility: nil, **options)
+				# @parameter arguments [Array] Arguments passed to the parent class.
+				# @parameter visibility [Symbol] The visibility of the definition (:public, :private, :protected).
+				# @parameter node [Parser::AST::Node] The syntax tree node representing this definition.
+				# @parameter options [Hash] Additional options passed to the parent class.
+				def initialize(*arguments, visibility: nil, node: nil, **options)
 					super(*arguments, **options)
 					
-					@node = node
 					@visibility = visibility
+					@node = node
 				end
 				
-				def nested_name
-					"\##{@name}"
-				end
-				
-				# @attribute [Parser::AST::Node] The parser syntax tree node.
+				# The parser syntax tree node.
+				# @attribute [Parser::AST::Node] The AST node representing this definition.
 				attr :node
 				
-				# @attribute [Symbol] The visibility of the definition.
+				# The visibility of the definition.
+				# @attribute [Symbol] The visibility level (:public, :private, or :protected).
 				attr_accessor :visibility
 				
+				# Check if this definition is public.
+				# @returns [Boolean] True if the definition is public.
 				def public?
 					@visibility == :public
 				end
 				
+				# Check if this definition spans multiple lines.
+				# @returns [Boolean] True if the definition spans multiple lines.
 				def multiline?
-					@node.location.line != @node.location.last_line
+					@node.location.start_line != @node.location.end_line
 				end
 				
 				# The source code associated with the definition.
-				# @returns [String]
+				# @returns [String] The source code text for this definition.
 				def text
-					expression = @node.location.expression
-					lines = expression.source.lines
+					expression = @node.location
+					lines = expression.slice.lines
 					if lines.count == 1
 						return lines.first
 					else
-						if indentation = expression.source_line[/\A\s+/]
+						if indentation = expression.slice.lines.first[/\A\s+/]
 							# Remove all the indentation:
-							lines.each{|line| line.sub!(indentation, '')}
+							lines.each{|line| line.sub!(indentation, "")}
 						end
 						
 						return lines.join
 					end
 				end
 				
+				# Get the location of this definition.
+				# @returns [Location | Nil] The location object if source is available.
 				def location
-					expression = @node.location.expression
-					
-					Location.new(expression.source_buffer.name, expression.line)
+					if @source
+						Location.new(@source.path, @node.location.start_line)
+					end
 				end
 			end
 		end

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

@@ -3,13 +3,14 @@
 # Released under the MIT License.
 # Copyright, 2020-2024, by Samuel Williams.
 
-require_relative 'method'
+require_relative "method"
 
 module Decode
 	module Language
 		module Ruby
 			# A Ruby-specific function.
 			class Function < Method
+				# Generate a nested name for the function.
 				def nested_name
 					".#{@name}"
 				end

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

@@ -3,27 +3,37 @@
 # Released under the MIT License.
 # Copyright, 2021-2024, by Samuel Williams.
 
-require_relative 'reference'
-require_relative 'parser'
-require_relative 'code'
+require_relative "reference"
+require_relative "parser"
+require_relative "code"
+
+require_relative "../generic"
 
 module Decode
 	module Language
 		module Ruby
-			# The Ruby language.
+			# Represents the Ruby language implementation for parsing and analysis.
 			class Generic < Language::Generic
-				EXTENSIONS = ['.rb', '.ru']
+				EXTENSIONS = [".rb", ".ru"]
 				
+				# Get the parser for Ruby source code.
+				# @returns [Parser] The Ruby parser instance.
 				def parser
 					@parser ||= Parser.new(self)
 				end
 				
-				# Generate a language-specific reference.
-				# @parameter identifier [String] A valid identifier.
+				# Generate a language-specific reference for Ruby.
+				# @parameter identifier [String] A valid Ruby identifier.
+				# @returns [Reference] A Ruby-specific reference object.
 				def reference_for(identifier)
 					Reference.new(identifier, self)
 				end
 				
+				# Generate a code representation with syntax highlighting and link resolution.
+				# @parameter text [String] The source code text to format.
+				# @parameter index [Index] The index for resolving references.
+				# @parameter relative_to [Definition] The definition to resolve relative references from.
+				# @returns [Code] A formatted code object with syntax highlighting.
 				def code_for(text, index, relative_to: nil)
 					Code.new(text, index, relative_to: relative_to, language: self)
 				end

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

@@ -3,35 +3,57 @@
 # Released under the MIT License.
 # Copyright, 2020-2024, by Samuel Williams.
 
-require_relative 'definition'
+require_relative "definition"
 
 module Decode
 	module Language
 		module Ruby
 			# A Ruby-specific method.
 			class Method < Definition
+				# Initialize a new method definition.
+				# @parameter arguments [Array] The definition arguments.
+				# @parameter receiver [String] The method receiver (for class methods).
+				# @parameter options [Hash] Additional options.
+				def initialize(*arguments, receiver: nil, **options)
+					super(*arguments, **options)
+					@receiver = receiver
+				end
+				
+				attr :receiver
+				
+				# Generate a nested name for the method.
+				def nested_name
+					if @receiver
+						".#{self.name}"
+					else
+						"##{self.name}"
+					end
+				end
+				
 				# The short form of the method.
-				# e.g. `def puts`.
+				# e.g. `def puts` or `def self.puts`.
 				def short_form
-					@node.location.keyword.join(@node.location.name).source
+					if @receiver
+						"def #{@receiver}.#{@node.name}"
+					else
+						"def #{@node.name}"
+					end
 				end
 				
 				# The node which contains the function arguments.
 				def arguments_node
-					if node = @node.children[1]
-						if node.location.expression
-							return node
-						end
-					end
+					@node.parameters
 				end
 				
 				# The long form of the method.
-				# e.g. `def puts(*lines, separator: "\n")`.
+				# e.g. `def puts(*lines, separator: "\n")` or `def self.puts(*lines, separator: "\n")`.
 				def long_form
 					if arguments_node = self.arguments_node
-						@node.location.keyword.join(
-							arguments_node.location.expression
-						).source
+						if @receiver
+							"def #{@receiver}.#{@node.name}(#{arguments_node.location.slice})"
+						else
+							"def #{@node.name}(#{arguments_node.location.slice})"
+						end
 					else
 						self.short_form
 					end
@@ -43,6 +65,19 @@ module Decode
 					self.qualified_name
 				end
 				
+				# Override the qualified_name method to handle method name joining correctly
+				def qualified_name
+					@qualified_name ||= begin
+						if @parent
+							[@parent.qualified_name, self.nested_name].join("")
+						else
+							self.nested_name
+						end
+					end
+				end
+				
+				# Convert the method to a different kind of definition.
+				# @parameter kind [Symbol] The kind to convert to.
 				def convert(kind)
 					case kind
 					when :attribute

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

@@ -3,7 +3,7 @@
 # Released under the MIT License.
 # Copyright, 2020-2024, by Samuel Williams.
 
-require_relative 'definition'
+require_relative "definition"
 
 module Decode
 	module Language
@@ -15,29 +15,22 @@ module Decode
 					true
 				end
 				
-				def nested_name
-					"::#{name}"
-				end
-				
 				# The short form of the module.
 				# e.g. `module Barnyard`.
 				def short_form
-					"module #{path_name.last}"
+					"module #{self.name}"
 				end
 				
+				# Generate a long form representation of the module.
 				def long_form
 					qualified_form
 				end
 				
-				# The fully qualified name of the class.
+				# The fully qualified name of the module.
 				# e.g. `module ::Barnyard::Dog`.
 				def qualified_form
 					"module #{self.qualified_name}"
 				end
-				
-				def path_name
-					@name.to_s.split('::').map(&:to_sym)
-				end
 			end
 		end
 	end