type-guessr 0.0.1 → 0.0.3

data/lib/ruby_lsp/type_guessr/{graph_builder.rb → debug_graph_builder.rb}

@@ -4,7 +4,7 @@ module RubyLsp
   module TypeGuessr
     # Builds graph data from IR nodes for visualization
     # Uses body_nodes structure with value/receiver/args edges
-    class GraphBuilder
+    class DebugGraphBuilder
       def initialize(runtime_adapter)
         @runtime_adapter = runtime_adapter
       end
@@ -41,9 +41,7 @@ module RubyLsp
       # Limit to MAX_NODES to prevent infinite/huge graphs
       MAX_NODES = 200
 
-      private
-
-      def build_def_node_graph(def_node, def_key)
+      private def build_def_node_graph(def_node, def_key)
         method_scope = @scope_id.empty? ? "##{def_node.name}" : "#{@scope_id}##{def_node.name}"
 
         # 1. Add DefNode
@@ -72,7 +70,7 @@ module RubyLsp
         @nodes[return_key] = {
           key: return_key,
           type: "Return",
-          line: def_node.loc&.line,
+          offset: def_node.loc,
           inferred_type: infer_type_str(def_node),
           details: { virtual: true }
         }
@@ -84,7 +82,7 @@ module RubyLsp
         add_edge(return_key, def_key)
       end
 
-      def process_body_node(node, scope_id, return_sources)
+      private def process_body_node(node, scope_id, return_sources)
         return unless node
         return if @nodes.size >= MAX_NODES
 
@@ -137,6 +135,11 @@ module RubyLsp
             branch_key = process_body_node(branch, scope_id, return_sources)
             add_edge(branch_key, node_key) if branch_key
           end
+        when ::TypeGuessr::Core::IR::OrNode
+          [node.lhs, node.rhs].each do |child|
+            child_key = process_body_node(child, scope_id, return_sources)
+            add_edge(child_key, node_key) if child_key
+          end
         when ::TypeGuessr::Core::IR::LiteralNode
           # Process internal values (for Hash/Array literals with expressions) # -- values is an Array attribute, not Hash#values
           node.values&.each do |value_node|
@@ -149,7 +152,7 @@ module RubyLsp
         node_key
       end
 
-      def add_node(node, scope_id = @scope_id)
+      private def add_node(node, scope_id = @scope_id)
         node_key = node.node_key(scope_id)
         return node_key if @nodes.key?(node_key)
 
@@ -157,20 +160,20 @@ module RubyLsp
         node_key
       end
 
-      def add_edge(from_key, to_key)
+      private def add_edge(from_key, to_key)
         return unless from_key && to_key
 
         edge = { from: from_key, to: to_key }
         @edges << edge unless @edges.include?(edge)
       end
 
-      def infer_type_str(node)
+      private def infer_type_str(node)
         result = @runtime_adapter.infer_type(node)
         result.type.to_s
       end
 
       # BFS traversal for non-DefNode (fallback)
-      def traverse_dependencies(node, node_key)
+      private def traverse_dependencies(node, node_key)
         visited = Set.new
         queue = [[node, node_key]]
 
@@ -193,12 +196,12 @@ module RubyLsp
 
       # Extract scope_id from a node key
       # Key format: {scope_id}:{type}:{name}:{line}
-      def extract_scope_id(node_key)
+      private def extract_scope_id(node_key)
         # For root key like "Class:def:name:line", scope is "Class"
         # For "Class#method:type:name:line", scope is "Class#method"
         # Find the last occurrence of known type prefixes
-        type_prefixes = %w[def: param: call: lit: local_write: local_read: ivar_write: ivar_read: cvar_write: cvar_read: merge: const: bparam: return: class:
-                           self:]
+        type_prefixes = %w[def: param: call: lit: local_write: local_read: ivar_write: ivar_read:
+                           cvar_write: cvar_read: merge: or: const: bparam: return: class: self:]
         last_type_pos = nil
 
         type_prefixes.each do |prefix|
@@ -226,27 +229,27 @@ module RubyLsp
       end
 
       # Serialize a node to hash format
-      def serialize_node(node, node_key)
-        warn("[GraphBuilder] serialize_node: #{node_key}") if Config.debug?
+      private def serialize_node(node, node_key)
+        warn("[DebugGraphBuilder] serialize_node: #{node_key}") if ::TypeGuessr::Core::Config.debug?
         result = @runtime_adapter.infer_type(node)
-        warn("[GraphBuilder] infer_type done for: #{node_key}") if Config.debug?
+        warn("[DebugGraphBuilder] infer_type done for: #{node_key}") if ::TypeGuessr::Core::Config.debug?
 
         {
           key: node_key,
           type: node_type_name(node),
-          line: node.loc&.line,
+          offset: node.loc,
           inferred_type: result.type.to_s,
           details: extract_details(node, node_key)
         }
       end
 
       # Get the short type name for a node
-      def node_type_name(node)
-        node.class.name.split("::").last
+      private def node_type_name(node)
+        ::TypeGuessr::Core::IR.extract_last_name(node.class.name)
       end
 
       # Extract details based on node type
-      def extract_details(node, node_key)
+      private def extract_details(node, node_key)
         case node
         when ::TypeGuessr::Core::IR::DefNode
           # Build full method signature with param types
@@ -288,6 +291,8 @@ module RubyLsp
           { literal_type: node.type.to_s }
         when ::TypeGuessr::Core::IR::MergeNode
           { branches_count: node.branches.size }
+        when ::TypeGuessr::Core::IR::OrNode
+          { kind: "or" }
         when ::TypeGuessr::Core::IR::ConstantNode
           { name: node.name.to_s }
         when ::TypeGuessr::Core::IR::BlockParamSlot
@@ -302,7 +307,7 @@ module RubyLsp
       end
 
       # Format receiver node for display
-      def format_receiver(receiver)
+      private def format_receiver(receiver)
         return nil unless receiver
 
         case receiver
@@ -321,7 +326,7 @@ module RubyLsp
 
       # Infer node key for a dependency
       # Uses parent node info to determine correct scope for children
-      def infer_dependency_key(dep_node, parent_key, parent_node = nil)
+      private def infer_dependency_key(dep_node, parent_key, parent_node = nil)
         # Extract scope_id from parent key
         # Key format: {scope_id}:{type}:{name}:{line}
         # scope_id can contain :: for namespaces and # for methods

data/lib/ruby_lsp/type_guessr/debug_server.rb

@@ -3,7 +3,7 @@
 require "socket"
 require "json"
 require "cgi"
-require_relative "graph_builder"
+require_relative "debug_graph_builder"
 
 module RubyLsp
   module TypeGuessr
@@ -16,7 +16,7 @@ module RubyLsp
       def initialize(global_state, runtime_adapter, port: DEFAULT_PORT)
         @global_state = global_state
         @runtime_adapter = runtime_adapter
-        @graph_builder = GraphBuilder.new(runtime_adapter)
+        @graph_builder = DebugGraphBuilder.new(runtime_adapter)
         @port = port
         @server = nil
         @thread = nil
@@ -38,9 +38,7 @@ module RubyLsp
         @server = nil
       end
 
-      private
-
-      def run_server
+      private def run_server
         @server = TCPServer.new("127.0.0.1", @port)
         warn("[TypeGuessr DebugServer] Listening on 127.0.0.1:#{@port}")
 
@@ -63,7 +61,7 @@ module RubyLsp
         warn("[TypeGuessr DebugServer] #{e.backtrace&.first(5)&.join("\n")}")
       end
 
-      def handle_request(client)
+      private def handle_request(client)
         request_line = client.gets
         return client.close if request_line.nil?
 
@@ -85,7 +83,7 @@ module RubyLsp
         client.close
       end
 
-      def parse_query_string(query_string)
+      private def parse_query_string(query_string)
         return {} unless query_string
 
         query_string.split("&").to_h do |pair|
@@ -94,7 +92,7 @@ module RubyLsp
         end
       end
 
-      def route_request(path, params)
+      private def route_request(path, params)
         case path
         when "/"
           index_page
@@ -111,7 +109,7 @@ module RubyLsp
         end
       end
 
-      def send_response(client, response)
+      private def send_response(client, response)
         client.print "HTTP/1.1 #{response[:status]}\r\n"
         client.print "Content-Type: #{response[:content_type]}\r\n"
         client.print "Content-Length: #{response[:body].bytesize}\r\n"
@@ -122,14 +120,14 @@ module RubyLsp
 
       # API Endpoints
 
-      def search_api(query)
+      private def search_api(query)
         return json_response({ query: query, results: [] }) if query.empty?
 
         results = @runtime_adapter.search_project_methods(query)
         json_response({ query: query, results: results })
       end
 
-      def keys_api(query)
+      private def keys_api(query)
         all_keys = @runtime_adapter.instance_variable_get(:@location_index)
                                    .instance_variable_get(:@key_index).keys
         keys = if query.empty?
@@ -140,7 +138,7 @@ module RubyLsp
         json_response({ query: query, total: all_keys.size, keys: keys })
       end
 
-      def graph_api(node_key)
+      private def graph_api(node_key)
         return json_error("node_key parameter required", 400) if node_key.empty?
 
         begin
@@ -164,7 +162,7 @@ module RubyLsp
         end
       end
 
-      def json_response(data)
+      private def json_response(data)
         {
           status: "200 OK",
           content_type: "application/json; charset=utf-8",
@@ -172,7 +170,7 @@ module RubyLsp
         }
       end
 
-      def json_error(message, status_code)
+      private def json_error(message, status_code)
         status_text = status_code == 404 ? "Not Found" : "Bad Request"
         {
           status: "#{status_code} #{status_text}",
@@ -181,7 +179,7 @@ module RubyLsp
         }
       end
 
-      def not_found
+      private def not_found
         {
           status: "404 Not Found",
           content_type: "text/html; charset=utf-8",
@@ -191,7 +189,7 @@ module RubyLsp
 
       # HTML Pages
 
-      def index_page
+      private def index_page
         {
           status: "200 OK",
           content_type: "text/html; charset=utf-8",
@@ -337,7 +335,7 @@ module RubyLsp
         }
       end
 
-      def graph_page(node_key)
+      private def graph_page(node_key)
         return not_found if node_key.empty?
 
         {
@@ -808,6 +806,10 @@ module RubyLsp
                     return escapeForMermaid(`Merge (${d.branches_count} branches)\\n(L${node.line})`);
                   }
 
+                  if (node.type === 'OrNode') {
+                    return escapeForMermaid(`Or (||)\\n(L${node.line})`);
+                  }
+
                   // Default format for other nodes
                   let label = node.type;
                   if (d.name) label += `: ${d.name}`;
@@ -838,6 +840,7 @@ module RubyLsp
                     ParamNode: 'paramNode',
                     LiteralNode: 'literalNode',
                     MergeNode: 'mergeNode',
+                    OrNode: 'mergeNode',
                     BlockParamSlot: 'blockParamNode'
                   };
                   return styles[nodeType] || 'otherNode';