lowkey 0.4.3 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 23f484029089a05bd14c027fdd8f8282afd3264c18e45c1c7cfe18237f09bf7a
-  data.tar.gz: 432014f7350e077fdf38610deb9cd76b6ae8f35d08b6128e2a3bafa543f019d0
+  metadata.gz: 1a54c7a7c2d38827bf0eec31f56a83ca054e46b44312ee2ead8a39d0630f00c8
+  data.tar.gz: 4e77aca4128ce3cec24cd077c75922aa8a2ef22e6cccb76fefbab0cbfe41f5c0
 SHA512:
-  metadata.gz: a4012dbb3d72a2ff26984a1347f4c7465d1fc12bab6faf1cb7f95ed089d2eccc254832653d69f1fe7faf73812770f5717ab1fcd2eb642db941169091a968b89d
-  data.tar.gz: c6c5f289593a2bb2ff626649d4a36e3bb71bd4ff19607ea3ba417e5188c64d5e125d6bdca133cab2275b952dd5820a646262844f57b8f77fbd89bc7302b6d077
+  metadata.gz: 5a76a77c867d1051d553f8af3309dc389b3d8b37e168cd7152e954625306f2666dd4ab8b3ac78c2a5c2063a4adfa7b738a5f3cadb220c3bd6804fedeaf42dd8d
+  data.tar.gz: ee32de9dd6b3fe80c96422744ba8077605babe0ed3d5ffaa9a28a8609fd20873bd404dd04b3e453628b6567e909575c33f9159fa65120a891e319df15372327e

data/lib/adapters/sinatra_adapter.rb

@@ -12,8 +12,10 @@ module Lowkey
 
     def load # rubocop:disable Metrics/AbcSize
       # Type check return values.
-      @class_proxy.method_calls.each do |method_call_node|
-        next unless %i[get post patch put delete options].include?(method_call_node.name)
+      @class_proxy.method_calls.each do |method_call|
+        next unless %i[get post patch put delete options].include?(method_call.name)
+
+        method_call_node = method_call.node
 
         arguments_node = method_call_node.compact_child_nodes.first
         next unless arguments_node.is_a?(Prism::ArgumentsNode)
@@ -23,7 +25,7 @@ module Lowkey
         name = route
         source = SourceFactory.method_call_source(method_call_node:, arguments_node:, file_path:, lines:)
 
-        next unless (return_proxy = ProxyFactory.return_proxy(method_node: method_call_node, name:, source:))
+        next unless (return_proxy = ProxyFactory.return_proxy(method_node: method_call_node, name:, file_path:, lines:))
 
         param_proxies = [ParamProxy.new(source:, name:, type: :pos_req, position: 0)]
         method_proxy = MethodProxy.new(source:, name:, param_proxies:, return_proxy:)

data/lib/factories/proxy_factory.rb

@@ -5,6 +5,7 @@ require_relative '../factories/source_factory'
 require_relative '../proxies/body_proxy'
 require_relative '../proxies/class_proxy'
 require_relative '../proxies/file_proxy'
+require_relative '../proxies/method_call_proxy'
 require_relative '../proxies/method_proxy'
 require_relative '../proxies/module_proxy'
 require_relative '../proxies/param_proxy'
@@ -37,9 +38,15 @@ module Lowkey
 
         param_proxies = param_proxies(parameters_node: method_node.parameters, file_path: file_proxy.file_path, source: method_source)
         body_proxy = BodyProxy.new(name:, source: body_source)
-        return_proxy = return_proxy(name:, method_node:, source: method_source)
+        return_proxy = return_proxy(name:, method_node:, file_path: file_proxy.file_path, lines: file_proxy.lines)
+        signature_end_line = signature_end_node(method_node:, return_proxy:)&.end_line || method_node.start_line
 
-        MethodProxy.new(name:, source: method_source, param_proxies:, body_proxy:, return_proxy:)
+        MethodProxy.new(name:, source: method_source, param_proxies:, body_proxy:, return_proxy:, signature_end_line:,
+                        receiver: method_node.receiver&.slice, node: method_node)
+      end
+
+      def method_call_proxy(call_node:, file_path:, lines:)
+        MethodCallProxy.new(name: call_node.name, node: call_node, file_path:, lines:)
       end
 
       def param_proxies(parameters_node:, source:, file_path:)
@@ -57,23 +64,53 @@ module Lowkey
           name = param.name
           source = SourceFactory.param_source(param_node: param, file_path:, lines: source.lines)
           type = param_types[param.class]
-          value = param.respond_to?(:value) ? param.value.slice : ':LOWKEY_UNDEFINED'
+          value = param.respond_to?(:value) ? param.value.slice : :LOWKEY_UNDEFINED
 
-          ParamProxy.new(name:, source:, type:, position:, value:)
+          ParamProxy.new(name:, source:, type:, position:, value:, default: param_default(param:))
         end
       end
 
-      def return_proxy(method_node:, name:, source:)
+      def return_proxy(method_node:, name:, file_path:, lines:)
         return_node = find_return_node(method_node:)
         return nil if return_node.nil?
 
         value = return_node.body.slice
+        source = SourceFactory.return_source(return_node:, scope: name, file_path:, lines:)
 
         ReturnProxy.new(name:, source:, value:)
       end
 
+      # The default value of a param or argument is the last value in a chain of "|" operators: "Type | Type | 'default'".
+      # LowType's "value(Type)" wraps a type to be used as a default value.
+      def default_source(node:)
+        node = node.arguments.arguments.first if union?(node:)
+        node = node.arguments.arguments.first if value_call?(node:)
+
+        node.slice
+      end
+
+      def union?(node:)
+        node.is_a?(Prism::CallNode) && node.name == :| && node.arguments&.arguments&.one?
+      end
+
       private
 
+      def value_call?(node:)
+        node.is_a?(Prism::CallNode) && node.receiver.nil? && %i[value low_value].include?(node.name) &&
+          node.arguments&.arguments&.one?
+      end
+
+      # The last node of a method's signature: "def name(params) -> { ReturnType }".
+      def signature_end_node(method_node:, return_proxy:)
+        return find_return_node(method_node:) if return_proxy
+
+        method_node.rparen_loc || method_node.parameters || method_node.name_loc
+      end
+
+      def param_default(param:)
+        param.respond_to?(:value) ? default_source(node: param.value) : nil
+      end
+
       # A return type is an unassigned lambda defined immediately after a method's parameters/block.
       def find_return_node(method_node:)
         # Method statements.

data/lib/factories/source_factory.rb

@@ -34,7 +34,7 @@ module Lowkey
         # TODO: Brittle conditional. What we really want to identify is if the method/rest of file was able to be parsed into an AST.
         end_line = end_line_from_indent(method_node:, lines:) if end_line >= lines.count
 
-        Source.new(file_path:, scope:, lines:, start_line:, end_line:)
+        Source.new(file_path:, scope:, lines:, start_line:, end_line:, location: method_node.location)
       end
 
       def param_source(param_node:, file_path:, lines:)
@@ -42,7 +42,14 @@ module Lowkey
         start_line = param_node.start_line
         end_line = param_node.end_line
 
-        Source.new(file_path:, scope:, lines:, start_line:, end_line:)
+        Source.new(file_path:, scope:, lines:, start_line:, end_line:, location: param_node.location)
+      end
+
+      def return_source(return_node:, scope:, file_path:, lines:)
+        start_line = return_node.start_line
+        end_line = return_node.end_line
+
+        Source.new(file_path:, scope:, lines:, start_line:, end_line:, location: return_node.location)
       end
 
       def body_source(method_source:)
@@ -53,6 +60,11 @@ module Lowkey
         Source.new(file_path: method_source.file_path, scope: method_source.scope, lines: method_source.lines, start_line:, end_line:)
       end
 
+      def call_source(call_node:, file_path:, lines:)
+        Source.new(file_path:, scope: call_node.name, lines:, start_line: call_node.start_line, end_line: call_node.end_line,
+                   location: call_node.location)
+      end
+
       def method_call_source(method_call_node:, arguments_node:, file_path:, lines:)
         pattern = arguments_node.arguments.first.content
         scope = "#{method_call_node.name.upcase} #{pattern}"

data/lib/interfaces/proxy.rb

@@ -1,21 +1,40 @@
 # frozen_string_literal: true
 
-require 'forwardable'
-
 module Lowkey
   # Proxy and Source abstract away nodes and avoid referencing the node on the proxy itself. Will this change?
   # The goal is to make an API that's indiependent of the AST, that can manipulate source code line by line.
+  #
+  # Methods delegate to the source by hand, as Forwardable allocates an array of arguments on every call.
+  # Subclasses can build their source on first access by overriding "source".
   class Proxy
-    extend Forwardable
-
-    attr_reader :name
-
-    def_delegators :@source, :file_path, :lines, :lines=, :start_line, :end_line, :scope
-    def_delegators :@source, :wrap, :export
+    attr_reader :name, :source
 
     def initialize(name:, source:)
       @name = name
       @source = source
     end
+
+    def file_path = source.file_path
+    def scope = source.scope
+
+    def lines = source.lines
+
+    def lines=(new_lines)
+      source.lines = new_lines
+    end
+
+    def start_line = source.start_line
+    def end_line = source.end_line
+    def start_index = source.start_index
+    def end_index = source.end_index
+
+    def start_offset = source.start_offset
+    def end_offset = source.end_offset
+    def start_column = source.start_column
+    def end_column = source.end_column
+    def line_offset = source.line_offset
+
+    def wrap(prefix:, suffix:) = source.wrap(prefix:, suffix:)
+    def export = source.export
   end
 end

data/lib/interfaces/releasable_node.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Lowkey
+  class ReleasedNodeError < StandardError
+    def initialize(message = 'Prism nodes are released once a file loads. Set "Lowkey.config.release_nodes = false" to keep them.')
+      super
+    end
+  end
+
+  # A proxy whose Prism node is released once its file loads, as nodes use most of a cached file's memory.
+  module ReleasableNode
+    def node
+      raise ReleasedNodeError if @node_released
+
+      @node
+    end
+
+    def release_node
+      @node = nil
+      @node_released = true
+    end
+  end
+end

data/lib/lowkey.rb

@@ -9,17 +9,22 @@ require_relative 'visitors/visitor'
 require_relative 'proxies/file_proxy'
 
 module Lowkey
+  NAMESPACE_PATTERN = /\A[A-Z]\w*(::[A-Z]\w*)*\z/
+
   class << self
     def keys
       @keys ||= {}
     end
 
+    # A namespace returns its file proxies. A file path returns its file proxy, loading the file on first access.
     def [](key)
-      keys[key]
+      return keys[key] if keys.key?(key) || !file_path?(key)
+
+      load(key)
     end
 
-    def load(file_path, cache: true)
-      root_node = Prism.parse_file(file_path).value
+    def load(file_path, cache: true, release_nodes: config.release_nodes)
+      root_node = Prism.parse(File.read(file_path), filepath: file_path).value
       file_proxy = ProxyFactory.file_proxy(root_node:, file_path:)
 
       parent_map = ParentMap.new(root_node:)
@@ -33,16 +38,35 @@ module Lowkey
         map_definitions(file_proxy:)
       end
 
+      file_proxy.release_nodes if release_nodes
       file_proxy
     end
 
-    def clear
-      keys.clear
+    def kept
+      @kept ||= Set.new
+    end
+
+    # Keeps a file proxy in the cache when it's cleared, for gems that look it up after the app has loaded.
+    def keep(file_proxy)
+      kept << file_proxy
+    end
+
+    # Clears cached file proxies to save memory, such as in a boot file once an app has loaded.
+    # Kept file proxies stay along with their namespaces, unless "keep" is false.
+    def clear(keep: true)
+      kept.clear unless keep
+
+      keys.select! do |_key, value|
+        next kept.include?(value) unless value.is_a?(Array)
+
+        value.select! { |file_proxy| kept.include?(file_proxy) }
+        !value.empty?
+      end
     end
 
     def config
-      config = Struct.new(:cache)
-      @config ||= config.new(true)
+      config = Struct.new(:cache, :release_nodes)
+      @config ||= config.new(true, true)
     end
 
     def configure
@@ -51,6 +75,10 @@ module Lowkey
 
     private
 
+    def file_path?(key)
+      key.is_a?(String) && !key.match?(NAMESPACE_PATTERN) && File.file?(key)
+    end
+
     def map_file_path(file_proxy:)
       keys[file_proxy.file_path] = file_proxy
 

data/lib/maps/parent_map.rb

@@ -2,8 +2,12 @@
 
 module Lowkey
   class ParentMap
+    # The namespace of each node, cached by Query#namespace.
+    attr_reader :namespaces
+
     def initialize(root_node:)
       @parent_map = {}
+      @namespaces = {}
       @current_parent = nil
 
       map(root_node)

data/lib/models/source.rb

@@ -4,16 +4,22 @@ module Lowkey
   class WriteError < StandardError; end
 
   class Source
-    attr_reader :file_path, :scope, :lines
+    attr_reader :file_path, :scope, :lines, :start_offset, :end_offset, :start_column, :end_column
     attr_accessor :start_line, :end_line
 
-    def initialize(file_path:, scope:, lines:, start_line:, end_line: nil)
+    # Offsets are byte offsets of the node in the original file. Columns are byte columns.
+    def initialize(file_path:, scope:, lines:, start_line:, end_line: nil, location: nil) # rubocop:disable Metrics/ParameterLists
       @file_path = file_path
       @scope = scope
 
       @start_line = start_line
       @end_line = end_line
       @lines = lines
+
+      @start_offset = location&.start_offset
+      @end_offset = location&.end_offset
+      @start_column = location&.start_column
+      @end_column = location&.end_column
     end
 
     def lines=(new_lines)
@@ -38,7 +44,25 @@ module Lowkey
       lines[start_index..end_index].join
     end
 
-    private
+    # Applies edits of [start_offset, end_offset, text] to a range of lines, keeping the amount of lines the same so that
+    # other sources sharing the lines stay valid. Offsets are byte offsets from the start of the range's first line.
+    def rewrite_lines(range:, edits:)
+      new_lines = apply_edits(text: lines[range].join.b, edits:).force_encoding(encoding).lines
+      raise WriteError, "More new lines than old lines, won't fit" if new_lines.count > range.count
+
+      lines[range] = new_lines + Array.new(range.count - new_lines.count, '')
+    end
+
+    def encoding
+      lines.first&.encoding || Encoding::UTF_8
+    end
+
+    # Edits are applied from last to first so that their offsets stay valid.
+    def apply_edits(text:, edits:)
+      edits.sort_by { |start_offset, _end_offset, _text| -start_offset }.reduce(text) do |new_text, (start_offset, end_offset, edit)|
+        new_text.byteslice(0, start_offset) + edit.b + new_text.byteslice(end_offset..)
+      end
+    end
 
     def start_index
       start_line - 1
@@ -47,5 +71,10 @@ module Lowkey
     def end_index
       end_line - 1
     end
+
+    # The byte offset of the start of the first line.
+    def line_offset
+      start_offset - start_column
+    end
   end
 end

data/lib/proxies/file_proxy.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../interfaces/proxy'
+require_relative '../interfaces/releasable_node'
 require_relative '../proxies/class_proxy'
 require_relative '../queries/query'
 
@@ -8,7 +9,6 @@ module Lowkey
   class FileProxy < Proxy
     include Query
 
-    attr_reader :root_node
     attr_accessor :definitions, :dependencies
 
     def initialize(root_node:, source:)
@@ -22,7 +22,20 @@ module Lowkey
 
     def [](keypath)
       namespace, *file_path = keypath.split('.')
-      file_path.empty? ? @definitions[namespace] : query(node: @root_node, namespace:, name: file_path.join)
+      file_path.empty? ? @definitions[namespace] : query(node: root_node, namespace:, name: file_path.join)
+    end
+
+    def root_node
+      raise ReleasedNodeError if @nodes_released
+
+      @root_node
+    end
+
+    # Prism's syntax tree uses most of a cached file proxy's memory, so it's released once the file is loaded.
+    def release_nodes
+      @root_node = nil
+      @nodes_released = true
+      @definitions.each_value(&:release_nodes)
     end
 
     def []=(keypath, value)

data/lib/proxies/method_call_proxy.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative '../factories/source_factory'
+require_relative '../interfaces/proxy'
+require_relative '../interfaces/releasable_node'
+
+module Lowkey
+  # A method call like "include Module", "attr_reader :name" or "type(String | 'default')".
+  # Details, including the source, are read from the node on first access as consumers often only need a few method calls.
+  class MethodCallProxy < Proxy
+    include ReleasableNode
+
+    def initialize(name:, node:, file_path:, lines:)
+      super(name:, source: nil)
+
+      @node = node
+      @file_path = file_path
+      @lines = lines
+      @rewritten = false
+    end
+
+    # The file path and lines don't need the node, so they're still available once nodes are released.
+    attr_reader :file_path, :lines
+
+    def source
+      @source ||= SourceFactory.call_source(call_node: node, file_path: @file_path, lines: @lines)
+    end
+
+    # The source of the receiver in "receiver.method", such as "self".
+    def receiver
+      return @receiver if defined?(@receiver)
+
+      @receiver = node.receiver&.slice
+    end
+
+    def receiver?
+      !receiver.nil?
+    end
+
+    # The source of each argument.
+    def arguments
+      @arguments ||= argument_nodes.map(&:slice)
+    end
+
+    # The keys of a hash argument like "method key: value" when every key is a symbol, otherwise nil.
+    def keywords
+      return @keywords if defined?(@keywords)
+
+      hash = argument_nodes.last
+      symbol_keys = (hash.is_a?(Prism::KeywordHashNode) || hash.is_a?(Prism::HashNode)) &&
+                    hash.elements.all? { |element| element.is_a?(Prism::AssocNode) && element.key.is_a?(Prism::SymbolNode) }
+
+      @keywords = symbol_keys ? hash.elements.map { |element| element.key.unescaped.to_sym } : nil
+    end
+
+    # The source of the default value when the argument is "Type | 'default'".
+    def default
+      return @default if defined?(@default)
+
+      union = argument_nodes.one? && ProxyFactory.union?(node: argument_nodes.first)
+      @default = union ? ProxyFactory.default_source(node: argument_nodes.first) : nil
+    end
+
+    # Replaces the method call with text, once. Calls on the same line must be rewritten from last to first.
+    def rewrite(text)
+      return if @rewritten
+
+      source.rewrite_lines(range: start_index..end_index, edits: [[start_offset - line_offset, end_offset - line_offset, text]])
+      @rewritten = true
+    end
+
+    # Removes the method call, along with its lines when it's the only code on them, and any blank line left orphaned.
+    def remove
+      return if @rewritten
+      return rewrite('') unless own_lines?
+
+      (start_index..end_index).each { |index| lines[index] = '' }
+      remove_orphaned_blank_line
+      @rewritten = true
+    end
+
+    private
+
+    def argument_nodes
+      node.arguments&.arguments || []
+    end
+
+    def own_lines?
+      lines[start_index].b.byteslice(0, start_column).strip.empty? && lines[end_index].b.byteslice(end_column..).strip.empty?
+    end
+
+    # A blank line after a removed line is orphaned when it follows another blank line or opens a class/module.
+    def remove_orphaned_blank_line
+      next_index = ((end_index + 1)...lines.count).find { |index| lines[index] != '' }
+      return unless next_index && lines[next_index].strip.empty?
+
+      lines[next_index] = '' if orphaning_line?(line: previous_line(index: start_index))
+    end
+
+    def orphaning_line?(line:)
+      line.nil? || line.strip.empty? || line.match?(/\A\s*(?:class|module)\b/)
+    end
+
+    # Skips removed lines, which are empty strings rather than blank lines.
+    def previous_line(index:)
+      previous_index = (0...index).reverse_each.find { |line_index| lines[line_index] != '' }
+      previous_index ? lines[previous_index] : nil
+    end
+  end
+end

data/lib/proxies/method_proxy.rb

@@ -1,36 +1,65 @@
 # frozen_string_literal: true
 
 require_relative '../interfaces/proxy'
+require_relative '../interfaces/releasable_node'
 require_relative '../queries/query'
 
 module Lowkey
   class MethodProxy < Proxy
     include Query
+    include ReleasableNode
 
-    attr_reader :params, :body, :return_proxy
+    attr_reader :params, :body, :return_proxy, :signature_end_line, :receiver
 
-    def initialize(name:, source:, param_proxies: [], body_proxy: nil, return_proxy: nil)
+    # @param receiver - The source of the receiver in "def receiver.method", such as "self".
+    # @param node - The method's node, which is released once its file loads.
+    def initialize(name:, source:, param_proxies: [], body_proxy: nil, return_proxy: nil, signature_end_line: nil, receiver: nil, # rubocop:disable Metrics/ParameterLists
+                   node: nil)
       super(name:, source:)
 
+      @node = node
+      @receiver = receiver
       @params = param_proxies
       @body = body_proxy
       @return_proxy = return_proxy
+      @signature_end_line = signature_end_line || source.start_line
+      @rewritten = false
 
       @named_params = name_params
       @tagged_params = tag_params
     end
 
+    # Methods built from method calls, like Sinatra routes, have no method node to query.
     def [](key)
-      # TODO: Initialize method proxy with method node and support query code path.
-      key.start_with?('.') ? query(node: @node, namespace: nil, name: key.delete_prefix('.')) : @named_params[key]
+      return @named_params[key] unless key.start_with?('.')
+
+      query(node:, namespace: nil, name: key.delete_prefix('.')) if node
     end
 
     def tagged_params(tag)
       @tagged_params[tag] || []
     end
 
+    # Removes types from the signature, leaving the rest of the source as is. The amount of lines stays the same.
+    def rewrite_signature
+      return if @rewritten
+
+      signature_range = start_index..(signature_end_line - 1)
+
+      edits = param_edits
+      edits << return_type_edit(signature: lines[signature_range].join.b) if @return_proxy&.expression
+
+      @source.rewrite_lines(range: signature_range, edits:)
+      @rewritten = true
+    end
+
+    # Whether the method is defined on its receiver, such as "def self.method", rather than on the current class.
+    def receiver?
+      !@receiver.nil?
+    end
+
     def expressions?
-      @params.any?(&:expression) || @return_proxy
+      @params.any?(&:expression) || !@return_proxy&.expression.nil?
     end
 
     def params_with_expressions
@@ -39,6 +68,24 @@ module Lowkey
 
     private
 
+    def param_edits
+      params_with_expressions.map do |param|
+        [param.start_offset - line_offset, param.end_offset - line_offset, param.export(typed: false)]
+      end
+    end
+
+    # Also removes the whitespace before the return type, or the whole line when the return type is on its own line.
+    def return_type_edit(signature:)
+      start_offset = @return_proxy.start_offset - line_offset
+      end_offset = @return_proxy.end_offset - line_offset
+      line_start_offset = start_offset - @return_proxy.start_column
+      before = signature.byteslice(line_start_offset, @return_proxy.start_column)
+
+      return [line_start_offset, end_offset + 1, ''] if before.strip.empty? && signature.byteslice(end_offset) == "\n"
+
+      [start_offset - before[/[ \t]*\z/].bytesize, end_offset, '']
+    end
+
     def name_params
       @params.each_with_object({}) do |param, named_params|
         named_params[param.name] = param if %i[pos_req pos_opt key_req key_opt].include?(param.type)

data/lib/proxies/module_proxy.rb

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
 
 require_relative '../interfaces/proxy'
+require_relative '../interfaces/releasable_node'
 require_relative '../queries/query'
 
 module Lowkey
   class ModuleProxy < Proxy
     include Query
+    include ReleasableNode
 
     attr_reader :namespace
-    attr_accessor :private_start_line, :keyed_methods, :class_methods, :method_calls
+    attr_accessor :private_start_line, :keyed_methods, :class_methods
 
     def initialize(node:, name:, namespace:, source:)
       super(name:, source:)
@@ -21,24 +23,105 @@ module Lowkey
       @keyed_methods = {}
       @class_methods = {}
 
-      @method_calls = []
+      @method_call_nodes = []
+      @method_calls = nil
+    end
+
+    # Method call proxies are lazy loaded and may not always be needed.
+    def method_calls
+      @method_calls ||= method_call_nodes.map { |call_node| method_call_proxy(call_node:) }
+    end
+
+    def add_method_call(node:)
+      @method_call_nodes << node
+      @method_calls << method_call_proxy(call_node: node) if @method_calls
     end
 
     def [](key)
-      key.start_with?('.') ? query(node: @node, namespace: nil, name: key.delete_prefix('.')) : @keyed_methods[key]
+      key.start_with?('.') ? query(node:, namespace: nil, name: key.delete_prefix('.')) : @keyed_methods[key]
+    end
+
+    # Also releases the nodes of its methods and method calls.
+    def release_nodes
+      release_node
+      @method_call_nodes = nil
+      @method_calls&.each(&:release_node)
+      method_proxies.each(&:release_node)
     end
 
     class << self
+      # "def self.method", "def ClassName.method" or a method within "class << self"/"class << ClassName".
       def class_method?(method_node:, parent_map:)
-        return true if method_node.is_a?(::Prism::DefNode) && method_node.receiver.instance_of?(Prism::SelfNode) # self.method_name
-        return true if method_node.is_a?(::Prism::SingletonClassNode) # class << self
+        return class_receiver?(receiver: method_node.receiver, node: method_node, parent_map:) if method_node.receiver
+        return false unless (singleton_class_node = singleton_class_node(method_node:, parent_map:))
 
-        if (parent_node = parent_map[method_node])
-          return class_method?(method_node: parent_node, parent_map:)
-        end
+        class_receiver?(receiver: singleton_class_node.expression, node: singleton_class_node, parent_map:)
+      end
 
+      # A method defined on an object, like "def object.method" or a method within "class << object".
+      def singleton_method?(method_node:, parent_map:)
+        !method_node.receiver.nil? || !singleton_class_node(method_node:, parent_map:).nil?
+      end
+
+      # Any other receiver, like "def object.method", defines a method on that object rather than the class.
+      def class_receiver?(receiver:, node:, parent_map:)
+        receiver = unwrap(node: receiver)
+        return true if receiver.is_a?(::Prism::SelfNode)
+        return false unless receiver.is_a?(::Prism::ConstantReadNode) || receiver.is_a?(::Prism::ConstantPathNode)
+
+        # The receiver can be the class name or any part of its namespace, like "Name" or "Namespace::Name".
+        "::#{namespace(node:, parent_map:)}".end_with?("::#{receiver.full_name}")
+      rescue ::Prism::ConstantPathNode::DynamicPartsInConstantPathError
         false
       end
+
+      private
+
+      def singleton_class_node(method_node:, parent_map:)
+        node = parent_map[method_node]
+        node = parent_map[node] until node.nil? || module_node?(node) || node.is_a?(::Prism::SingletonClassNode)
+
+        node.is_a?(::Prism::SingletonClassNode) ? node : nil
+      end
+
+      # "def (Namespace::Name).method" wraps the receiver in parentheses.
+      def unwrap(node:)
+        return node unless node.is_a?(::Prism::ParenthesesNode)
+
+        body = node.body
+        body.is_a?(::Prism::StatementsNode) && body.body.one? ? body.body.first : body
+      end
+
+      def namespace(node:, parent_map:)
+        names = []
+
+        while (node = parent_map[node])
+          names.unshift(node.constant_path.full_name) if module_node?(node)
+        end
+
+        names.join('::')
+      end
+
+      def module_node?(node)
+        node.is_a?(::Prism::ClassNode) || node.is_a?(::Prism::ModuleNode)
+      end
+    end
+
+    private
+
+    # Method proxies with the same name share a key in "keyed_methods", so instance and class methods are included.
+    def method_proxies
+      [*@keyed_methods.values, *@class_methods.values, *(instance_methods.values if respond_to?(:instance_methods))].uniq
+    end
+
+    def method_call_nodes
+      raise ReleasedNodeError if @method_call_nodes.nil?
+
+      @method_call_nodes
+    end
+
+    def method_call_proxy(call_node:)
+      ProxyFactory.method_call_proxy(call_node:, file_path:, lines:)
     end
   end
 end

data/lib/proxies/param_proxy.rb

@@ -5,14 +5,17 @@ require_relative '../interfaces/proxy'
 module Lowkey
   class ParamProxy < Proxy
     attr_reader :type, :position, :value
-    attr_accessor :expression
+    attr_accessor :default, :expression
 
-    def initialize(name:, source:, type:, position: nil, value: :LOWKEY_UNDEFINED, expression: nil) # rubocop:disable Metrics/ParameterLists
+    # @param value - The source of the param's value, such as "String | 'default'".
+    # @param default - The source of the default value within the value, such as "'default'". Can be overridden.
+    def initialize(name:, source:, type:, position: nil, value: :LOWKEY_UNDEFINED, default: nil, expression: nil) # rubocop:disable Metrics/ParameterLists
       super(name:, source:)
 
       @type = type
       @position = position
       @value = value
+      @default = default
 
       @expression = expression
     end
@@ -20,5 +23,37 @@ module Lowkey
     def required?
       @value == :LOWKEY_UNDEFINED
     end
+
+    def export(typed: true)
+      return @source.export if typed
+      return untyped_keyword_param if %i[key_req key_opt].include?(@type)
+
+      untyped_positional_param
+    end
+
+    private
+
+    def untyped_keyword_param
+      default = resolved_default
+      default.nil? ? "#{@name}:" : "#{@name}: #{default}"
+    end
+
+    def untyped_positional_param
+      default = resolved_default
+      default.nil? ? @name.to_s : "#{@name} = #{default}"
+    end
+
+    # Uses the source of the default value rather than the evaluated default value, to preserve the developer's code.
+    def resolved_default
+      if @expression
+        return nil if @expression.required?
+
+        return @default
+      end
+
+      return nil if @value == :LOWKEY_UNDEFINED
+
+      @value
+    end
   end
 end

data/lib/queries/query.rb

@@ -11,18 +11,33 @@ module Lowkey
       end
     end
 
-    def namespace(node:, parent_map:, namespace: [])
+    def namespace(node:, parent_map:)
+      path = namespace_path(node:, parent_map:)
+      return nil if path.nil?
+
+      path.empty? ? 'Object' : path
+    end
+
+    private
+
+    # Each node caches the namespace above it, so our first ancestor will have the full namespace.
+    def namespace_path(node:, parent_map:)
+      namespaces = parent_map.namespaces
+      return namespaces[node] if namespaces.key?(node)
+
+      namespaces[node] = resolve_namespace_path(node:, parent_map:)
+    end
+
+    def resolve_namespace_path(node:, parent_map:)
       # When inside RBX, Prism thinks we're defining a class because of "<".
       return nil if node.respond_to?(:constant_path) && node.constant_path.is_a?(Prism::MissingNode)
+      return '' if (parent = parent_map[node]).nil?
 
-      if parent_map[node].nil?
-        namespace << 'Object' if namespace.empty?
-        return namespace.reverse.join('::')
-      end
-
-      namespace << node.constant_path.name.to_s if node.respond_to?(:constant_path)
+      path = namespace_path(node: parent, parent_map:)
+      return path if path.nil? || !node.respond_to?(:constant_path)
 
-      namespace(node: parent_map[node], parent_map:, namespace:)
+      name = node.constant_path.name.to_s
+      (path.empty? ? name : "#{path}::#{name}").freeze
     end
   end
 end

data/lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lowkey
-  VERSION = '0.4.3'
+  VERSION = '0.6.0'
 end

data/lib/visitors/method_call_visitor.rb

@@ -15,7 +15,7 @@ module Lowkey
       namespace = namespace(node:, parent_map:) || return
       module_proxy = file_proxy[namespace]
 
-      module_proxy.method_calls << node
+      module_proxy.add_method_call(node:)
       upsert_dependency(node:, namespace:)
 
       return unless node.name == :private && node.respond_to?(:start_line) && module_proxy.start_line && module_proxy.end_line

data/lib/visitors/method_def_visitor.rb

@@ -20,17 +20,20 @@ module Lowkey
       method_proxy = ProxyFactory.method_proxy(method_node:, file_proxy:)
 
       module_proxy.keyed_methods[method_node.name] = method_proxy
+      tag_method(method_node:, method_proxy:, module_proxy:)
+    end
+
+    private
 
-      # TODO: Implemented as tagged methods similar to tagged params.
+    # TODO: Implemented as tagged methods similar to tagged params.
+    def tag_method(method_node:, method_proxy:, module_proxy:)
       if ModuleProxy.class_method?(method_node:, parent_map:)
         module_proxy.class_methods[method_node.name] = method_proxy
-      elsif module_proxy.class <= ClassProxy
+      elsif module_proxy.class <= ClassProxy && !ModuleProxy.singleton_method?(method_node:, parent_map:)
         module_proxy.instance_methods[method_node.name] = method_proxy
       end
     end
 
-    private
-
     attr_reader :file_proxy, :parent_map
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: lowkey
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.6.0
 platform: ruby
 authors:
 - maedi
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
@@ -37,12 +37,14 @@ files:
 - lib/factories/source_factory.rb
 - lib/interfaces/adapter.rb
 - lib/interfaces/proxy.rb
+- lib/interfaces/releasable_node.rb
 - lib/lowkey.rb
 - lib/maps/parent_map.rb
 - lib/models/source.rb
 - lib/proxies/body_proxy.rb
 - lib/proxies/class_proxy.rb
 - lib/proxies/file_proxy.rb
+- lib/proxies/method_call_proxy.rb
 - lib/proxies/method_proxy.rb
 - lib/proxies/module_proxy.rb
 - lib/proxies/param_proxy.rb
@@ -73,7 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 3.6.2
 specification_version: 4
 summary: An API for accessing PRISM metadata easily and efficiently
 test_files: []