hind 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5fa041a7ffe7e916e1f3715500d21a9dea2a3a6ce60990be8cf4e7578f704702
-  data.tar.gz: '0779f87c520ddc1edddf0448c96d596194982d5b87fa5c380bb3a1132500bd9e'
+  metadata.gz: 65e6158fb36117206f66c5989febbd5c336f7b8e88aa3b4a241a7d2cac091fa1
+  data.tar.gz: 753d17f81c708b80ebac94b1e17c1cfa2c34e4ed5bc767f9e2daed525b7485ab
 SHA512:
-  metadata.gz: 397847759b6c959511602d276eee22f7e89959c5858d840cf8398b874a39ef6ccfeec8d876e9c0539d5cc0bc0cce77cb1e297b7fabc30c9a4562bfb7e85ddb7b
-  data.tar.gz: 5c823067473c8b784a4868bf696b4374735b548eb8eb9341fb887dc78028e9223aeaac7172c621c624d0e8a3de221b50e101e908177626f9c316797e8ce2de70
+  metadata.gz: 649463b8b55e5016d822334667c1e61f6bc4fefa62230a5f7846f2b396f9ad467c8ff848d9637377c4851bda3d7bb068cc1a319a16d06b31a2269384bc6486c9
+  data.tar.gz: 0376aec80b6dbd5eba49244103d093a004e428e284e644b17109010a3175969f0df9eb261edc94fc60d071a8594a925aaa7ffa975af112c575b2781380e85beb

data/exe/hind

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require 'hind'
-require 'hind/cli'
+require_relative '../lib/hind'
+require_relative '../lib/hind/cli'
 
 Hind::CLI.start(ARGV)

data/lib/hind/cli.rb

@@ -8,9 +8,8 @@ require 'fileutils'
 module Hind
   class CLI < Thor
     class_option :verbose, type: :boolean, aliases: '-v', desc: 'Enable verbose output'
-    class_option :config, type: :string, aliases: '-c', desc: 'Path to configuration file'
 
-    desc 'lsif', 'Generate LSIF index'
+    desc 'lsif', 'Generate LSIF index for Ruby classes, modules, and constants'
     method_option :directory, type: :string, aliases: '-d', default: '.', desc: 'Root directory to process'
     method_option :output, type: :string, aliases: '-o', default: 'dump.lsif', desc: 'Output file path'
     method_option :glob, type: :string, aliases: '-g', default: '**/*.rb', desc: 'File pattern to match'
@@ -29,30 +28,7 @@ module Hind
         generate_lsif(files, options)
         say "\nLSIF data has been written to: #{options[:output]}", :green if options[:verbose]
       rescue => e
-        abort "Error generating LSIF: #{e.message}"
-      end
-    end
-
-    desc 'scip', 'Generate SCIP index'
-    method_option :directory, type: :string, aliases: '-d', default: '.', desc: 'Root directory to process'
-    method_option :output, type: :string, aliases: '-o', default: 'index.scip', desc: 'Output file path'
-    method_option :glob, type: :string, aliases: '-g', default: '**/*.rb', desc: 'File pattern to match'
-    method_option :force, type: :boolean, aliases: '-f', desc: 'Overwrite output file if it exists'
-    method_option :exclude, type: :array, aliases: '-e', desc: 'Patterns to exclude'
-    def scip
-      validate_directory(options[:directory])
-      validate_output_file(options[:output], options[:force])
-
-      files = find_files(options[:directory], options[:glob], options[:exclude])
-      abort "No files found matching pattern '#{options[:glob]}'" if files.empty?
-
-      say "Found #{files.length} files to process", :green if options[:verbose]
-
-      begin
-        generate_scip(files, options)
-        say "\nSCIP data has been written to: #{options[:output]}", :green if options[:verbose]
-      rescue => e
-        abort "Error generating SCIP: #{e.message}"
+        handle_error(e, options[:verbose])
       end
     end
 
@@ -63,12 +39,65 @@ module Hind
 
     private
 
+    def generate_lsif(files, options)
+      # Initialize generator with absolute project root
+      generator = Hind::LSIF::Generator.new(
+        {
+          vertex_id: 1,
+          initial: true,
+          projectRoot: File.expand_path(options[:directory])
+        }
+      )
+
+      # Create file content map with relative paths
+      file_contents = {}
+      files.each do |file|
+        absolute_path = File.expand_path(file)
+        relative_path = Pathname.new(absolute_path)
+          .relative_path_from(Pathname.new(generator.metadata[:projectRoot]))
+          .to_s
+
+        begin
+          file_contents[relative_path] = File.read(absolute_path)
+        rescue => e
+          warn "Warning: Failed to read file '#{file}': #{e.message}"
+          next
+        end
+      end
+
+      File.open(options[:output], 'w') do |output_file|
+        say 'First pass: Collecting declarations...', :cyan if options[:verbose]
+
+        # First pass: Process all files to collect declarations
+        declaration_data = generator.collect_declarations(file_contents)
+
+        say "Found #{declaration_data[:declarations].size} declarations (classes, modules, constants)", :cyan if options[:verbose]
+        say 'Processing files for references...', :cyan if options[:verbose]
+
+        # Second pass: Process each file for references
+        file_contents.each do |relative_path, content|
+          if options[:verbose]
+            say "Processing file: #{relative_path}", :cyan
+          end
+
+          lsif_data = generator.process_file(
+            content: content,
+            uri: relative_path
+          )
+
+          output_file.puts(lsif_data.map(&:to_json).join("\n"))
+        end
+      end
+    end
+
     def validate_directory(directory)
       abort "Error: Directory '#{directory}' does not exist" unless Dir.exist?(directory)
     end
 
     def validate_output_file(output, force)
-      abort "Error: Output file '#{output}' already exists. Use --force to overwrite." if File.exist?(output) && !force
+      if File.exist?(output) && !force
+        abort "Error: Output file '#{output}' already exists. Use --force to overwrite."
+      end
 
       # Ensure output directory exists
       FileUtils.mkdir_p(File.dirname(output))
@@ -85,53 +114,10 @@ module Hind
       files
     end
 
-    def generate_lsif(files, options)
-      global_state = Hind::LSIF::GlobalState.new
-      vertex_id = 1
-      initial = true
-
-      File.open(options[:output], 'w') do |output_file|
-        files.each do |file|
-          say "Processing file: #{file}", :cyan if options[:verbose]
-
-          relative_path = Pathname.new(file).relative_path_from(Pathname.new(options[:directory])).to_s
-
-          begin
-            generator = Hind::LSIF::Generator.new(
-              {
-                uri: relative_path,
-                vertex_id: vertex_id,
-                initial: initial,
-                projectRoot: options[:directory]
-              },
-              global_state
-            )
-
-            output = generator.generate(File.read(file))
-            vertex_id = output.last[:id].to_i + 1
-            output_file.puts(output.map(&:to_json).join("\n"))
-            initial = false
-          rescue => e
-            warn "Warning: Failed to process file '#{file}': #{e.message}"
-            next
-          end
-        end
-      end
-    end
-
-    def generate_scip(files, options)
-      raise NotImplementedError, 'SCIP generation not yet implemented'
-      # Similar to generate_lsif but using SCIP generator
-    end
-
-    def load_config(config_path)
-      return {} unless config_path && File.exist?(config_path)
-
-      begin
-        YAML.load_file(config_path) || {}
-      rescue => e
-        abort "Error loading config file: #{e.message}"
-      end
+    def handle_error(error, verbose)
+      message = "Error: #{error.message}"
+      message += "\n#{error.backtrace.join("\n")}" if verbose
+      abort message
     end
   end
 end

data/lib/hind/lsif/generator.rb

@@ -3,79 +3,127 @@
 require 'prism'
 require 'json'
 require 'uri'
+require 'pathname'
+
+require_relative 'visitors/declaration_visitor'
+require_relative 'visitors/reference_visitor'
 
 module Hind
   module LSIF
     class Generator
       LSIF_VERSION = '0.4.3'
 
-      attr_reader :global_state, :document_id, :metadata
+      attr_reader :metadata, :global_state, :document_id, :current_uri
 
-      def initialize(metadata = {}, global_state = nil)
+      def initialize(metadata = {})
         @vertex_id = metadata[:vertex_id] || 1
         @metadata = {
           language: 'ruby',
-          projectRoot: Dir.pwd
+          projectRoot: File.expand_path(metadata[:projectRoot] || Dir.pwd)
         }.merge(metadata)
 
-        @global_state = global_state || GlobalState.new
+        @global_state = GlobalState.new
         @document_ids = {}
+        @current_document_id = nil
         @lsif_data = []
+        @current_uri = nil
 
         initialize_project if metadata[:initial]
       end
 
-      def generate(code, file_metadata = {})
-        @metadata = @metadata.merge(file_metadata)
+      def collect_declarations(files)
+        files.each do |path, content|
+          @current_uri = path
+          @document_id = nil
+          @current_document_id = nil
+
+          begin
+            ast = Parser.new(content).parse
+            setup_document
+            visitor = DeclarationVisitor.new(self, path)
+            visitor.visit(ast)
+            finalize_document_state
+          rescue => e
+            warn "Warning: Failed to collect declarations from '#{path}': #{e.message}"
+          end
+        end
+
+        {declarations: @global_state.declarations}
+      end
+
+      def process_file(params)
+        @current_uri = params[:uri]
+        content = params[:content]
+
+        @document_id = nil
+        @current_document_id = nil
+
         setup_document
+        ast = Parser.new(content).parse
 
-        ast = Parser.new(code).parse
-        visitor = Visitor.new(self)
+        visitor = ReferenceVisitor.new(self, @current_uri)
         visitor.visit(ast)
 
-        finalize_document
-        update_cross_file_references
-
-        @lsif_data
+        result = @lsif_data
+        finalize_document_state
+        result
       end
 
-      def create_range(start_location, end_location)
-        range_id = emit_vertex('range', {
-          start: {
-            line: start_location.start_line - 1,
-            character: start_location.start_column
-          },
-          end: {
-            line: end_location.end_line - 1,
-            character: end_location.end_column
-          }
-        })
+      def register_declaration(declaration)
+        return unless @current_uri && declaration[:node]
 
-        file_path = File.join(@metadata[:projectRoot], @metadata[:uri])
-        @global_state.add_range(file_path, range_id)
-        range_id
-      end
+        qualified_name = declaration[:name]
 
-      def emit_vertex(label, data = nil)
-        vertex = Vertex.new(@vertex_id, label, data)
-        @lsif_data << vertex.to_json
-        @vertex_id += 1
-        @vertex_id - 1
-      end
+        setup_document if @document_id.nil?
+        current_doc_id = @document_id
 
-      def emit_edge(label, out_v, in_v, property = nil)
-        return unless out_v && valid_in_v?(in_v)
+        range_id = create_range(declaration[:node].location, declaration[:node].location)
+        return unless range_id
 
-        edge = Edge.new(@vertex_id, label, out_v, in_v, property, edge_document(label))
-        @lsif_data << edge.to_json
-        @vertex_id += 1
-        @vertex_id - 1
+        result_set_id = emit_vertex('resultSet')
+        emit_edge('next', range_id, result_set_id)
+
+        def_result_id = emit_vertex('definitionResult')
+        emit_edge('textDocument/definition', result_set_id, def_result_id)
+
+        emit_edge('item', def_result_id, [range_id], 'definitions', current_doc_id)
+
+        hover_content = generate_hover_content(declaration)
+        hover_id = emit_vertex('hoverResult', {
+          contents: [{
+            language: 'ruby',
+            value: hover_content
+          }]
+        })
+        emit_edge('textDocument/hover', result_set_id, hover_id)
+
+        @global_state.add_declaration(qualified_name, {
+          type: declaration[:type],
+          scope: declaration[:scope],
+          file: @current_uri,
+          range_id: range_id,
+          result_set_id: result_set_id,
+          document_id: current_doc_id
+        }.merge(declaration))
+
+        result_set_id
       end
 
-      def add_to_global_state(qualified_name, result_set_id, range_id)
-        file_path = File.join(@metadata[:projectRoot], @metadata[:uri])
-        @global_state.result_sets[qualified_name] = result_set_id
-        @global_state.add_definition(qualified_name, file_path, range_id)
+      def register_reference(reference)
+        return unless @current_uri && reference[:node]
+        return unless @global_state.has_declaration?(reference[:name])
+
+        setup_document if @document_id.nil?
+        current_doc_id = @document_id
+
+        range_id = create_range(reference[:node].location, reference[:node].location)
+        return unless range_id
+
+        declaration = @global_state.declarations[reference[:name]]
+        return unless declaration[:result_set_id]
+
+        @global_state.add_reference(reference[:name], @current_uri, range_id, current_doc_id)
+        emit_edge('next', range_id, declaration[:result_set_id])
       end
 
       private
@@ -87,7 +135,7 @@ module Hind
           positionEncoding: 'utf-16',
           toolInfo: {
             name: 'hind',
-            version: VERSION
+            version: Hind::VERSION
           }
         })
 
@@ -95,89 +143,138 @@ module Hind
       end
 
       def setup_document
-        file_path = File.join(@metadata[:projectRoot], @metadata[:uri])
+        return if @document_id
+        return unless @current_uri
+
+        file_path = File.join(@metadata[:projectRoot], @current_uri)
 
         @document_id = emit_vertex('document', {
           uri: path_to_uri(file_path),
           languageId: 'ruby'
         })
-        @document_ids[file_path] = @document_id
+
+        @document_ids[@current_uri] = @document_id
+        @current_document_id = @document_id
 
         emit_edge('contains', @global_state.project_id, [@document_id]) if @global_state.project_id
       end
 
-      def finalize_document
-        file_path = File.join(@metadata[:projectRoot], @metadata[:uri])
-        ranges = @global_state.ranges[file_path]
+      def finalize_document_state
+        return unless @current_uri && @document_id
+
+        ranges = @global_state.get_ranges_for_file(@current_uri)
+        if ranges&.any?
+          emit_edge('contains', @document_id, ranges, nil, @document_id)
+        end
+      end
 
-        return unless ranges&.any?
+      def create_range(start_location, end_location)
+        return nil unless @current_uri && start_location && end_location
 
-        emit_edge('contains', @document_id, ranges)
+        range_id = emit_vertex('range', {
+          start: {
+            line: start_location.start_line - 1,
+            character: start_location.start_column
+          },
+          end: {
+            line: end_location.end_line - 1,
+            character: end_location.end_column
+          }
+        })
+
+        @global_state.add_range(@current_uri, range_id)
+        range_id
       end
 
-      def update_cross_file_references
-        @global_state.references.each do |qualified_name, references|
-          definition = @global_state.definitions[qualified_name]
-          next unless definition
+      def emit_vertex(label, data = nil)
+        vertex = {
+          id: @vertex_id,
+          type: 'vertex',
+          label: label
+        }
+
+        if data
+          if %w[hoverResult definitionResult referenceResult].include?(label)
+            vertex[:result] = format_hover_data(data)
+          else
+            vertex.merge!(data)
+          end
+        end
 
-          result_set_id = @global_state.result_sets[qualified_name]
-          next unless result_set_id
+        @lsif_data << vertex
+        @vertex_id += 1
+        @vertex_id - 1
+      end
 
-          ref_result_id = emit_vertex('referenceResult')
-          emit_edge('textDocument/references', result_set_id, ref_result_id)
+      def emit_edge(label, out_v, in_v, property = nil, doc_id = nil)
+        return unless out_v && valid_in_v?(in_v)
 
-          # Collect all reference range IDs
-          all_refs = references.map { |ref| ref[:range_id] }
-          all_refs << definition[:range_id]
+        edge = {
+          id: @vertex_id,
+          type: 'edge',
+          label: label,
+          outV: out_v
+        }
 
-          # Group references by document
-          reference_documents = references.group_by { |ref| ref[:file] }
-          reference_documents.each_key do |file_path|
-            document_id = @document_ids[file_path]
-            next unless document_id
+        if in_v.is_a?(Array)
+          edge[:inVs] = in_v
+        else
+          edge[:inV] = in_v
+        end
 
-            emit_edge('item', ref_result_id, all_refs, 'references')
-          end
+        if label == 'item'
+          edge[:document] = doc_id || @current_document_id
+          edge[:property] = property if property
+        end
 
-          # Handle definition document if not already included
-          def_document_id = @document_ids[definition[:file]]
-          if def_document_id && references.none? { |ref| ref[:file] == definition[:file] }
-            emit_edge('item', ref_result_id, all_refs, 'references')
-          end
+        @lsif_data << edge
+        @vertex_id += 1
+        @vertex_id - 1
+      end
+
+      def generate_hover_content(declaration)
+        case declaration[:type]
+        when :class
+          hover = ["class #{declaration[:name]}"]
+          hover << " < #{declaration[:superclass]}" if declaration[:superclass]
+          hover.join
+        when :module
+          "module #{declaration[:name]}"
+        when :constant
+          value_info = declaration[:node].value ? " = #{declaration[:node].value.inspect}" : ''
+          "#{declaration[:name]}#{value_info}"
+        else
+          declaration[:name].to_s
+        end
+      end
+
+      def format_hover_data(data)
+        return data unless data[:contents]
+
+        data[:contents] = data[:contents].map do |content|
+          content[:value] = strip_code_block(content[:value])
+          content
         end
+        data
+      end
+
+      def strip_code_block(text)
+        text.gsub(/```.*\n?/, '').strip
       end
 
       def valid_in_v?(in_v)
         return false unless in_v
         return in_v.any? if in_v.is_a?(Array)
-
         true
       end
 
-      def edge_document(label)
-        (label == 'item') ? @document_id : nil
-      end
-
       def path_to_uri(path)
+        return nil unless path
         normalized_path = path.tr('\\', '/')
         normalized_path = normalized_path.sub(%r{^file://}, '')
         absolute_path = File.expand_path(normalized_path)
         "file://#{absolute_path}"
       end
-
-      def make_hover_content(text)
-        {
-          contents: [{
-            language: 'ruby',
-            value: strip_code_block(text)
-          }]
-        }
-      end
-
-      def strip_code_block(text)
-        # Strip any existing code block markers and normalize
-        text.gsub(/```.*\n?/, '').strip
-      end
     end
   end
 end

data/lib/hind/lsif/global_state.rb

@@ -1,17 +1,32 @@
+# lib/hind/lsif/global_state.rb
 # frozen_string_literal: true
 
 module Hind
   module LSIF
     class GlobalState
-      attr_reader :result_sets, :definitions, :references, :ranges
       attr_accessor :project_id
+      attr_reader :declarations, :references, :result_sets, :ranges
 
       def initialize
-        @result_sets = {}  # {qualified_name => result_set_id}
-        @definitions = {}  # {qualified_name => {file: file_path, range_id: id}}
-        @references = {}   # {qualified_name => [{file: file_path, range_id: id}]}
-        @ranges = {}       # {file_path => [range_ids]}
-        @project_id = nil  # Store project ID for reuse across files
+        @declarations = {}    # {qualified_name => {type:, node:, scope:, file:, range_id:, result_set_id:}}
+        @references = {}      # {qualified_name => [{file:, range_id:, type:}, ...]}
+        @result_sets = {}     # {qualified_name => result_set_id}
+        @ranges = {}          # {file_path => [range_ids]}
+        @project_id = nil
+      end
+
+      def add_declaration(qualified_name, data)
+        @declarations[qualified_name] = data
+        @result_sets[qualified_name] = data[:result_set_id] if data[:result_set_id]
+      end
+
+      def add_reference(qualified_name, file_path, range_id, document_id)
+        @references[qualified_name] ||= []
+        @references[qualified_name] << {
+          file: file_path,
+          range_id: range_id,
+          document_id: document_id
+        }
       end
 
       def add_range(file_path, range_id)
@@ -19,13 +34,60 @@ module Hind
         @ranges[file_path] << range_id
       end
 
-      def add_definition(qualified_name, file_path, range_id)
-        @definitions[qualified_name] = {file: file_path, range_id: range_id}
+      def has_declaration?(qualified_name)
+        @declarations.key?(qualified_name)
       end
 
-      def add_reference(qualified_name, file_path, range_id)
-        @references[qualified_name] ||= []
-        @references[qualified_name] << {file: file_path, range_id: range_id}
+      def get_declaration(qualified_name)
+        @declarations[qualified_name]
+      end
+
+      def get_references(qualified_name)
+        @references[qualified_name] || []
+      end
+
+      def get_result_set(qualified_name)
+        @result_sets[qualified_name]
+      end
+
+      def get_ranges_for_file(file_path)
+        @ranges[file_path] || []
+      end
+
+      def find_constant_declaration(name, current_scope)
+        return name if has_declaration?(name)
+
+        if current_scope && !current_scope.empty?
+          qualified_name = "#{current_scope}::#{name}"
+          return qualified_name if has_declaration?(qualified_name)
+
+          scope_parts = current_scope.split('::')
+          while scope_parts.any?
+            scope_parts.pop
+            qualified_name = scope_parts.empty? ? name : "#{scope_parts.join("::")}::#{name}"
+            return qualified_name if has_declaration?(qualified_name)
+          end
+        end
+
+        has_declaration?(name) ? name : nil
+      end
+
+      def debug_info
+        {
+          declarations_count: @declarations.size,
+          references_count: @references.values.sum(&:size),
+          result_sets_count: @result_sets.size,
+          ranges_count: @ranges.values.sum(&:size),
+          declaration_types: declaration_types_count
+        }
+      end
+
+      private
+
+      def declaration_types_count
+        @declarations.values.each_with_object(Hash.new(0)) do |decl, counts|
+          counts[decl[:type]] += 1
+        end
       end
     end
   end

data/lib/hind/lsif/visitors/declaration_visitor.rb

@@ -0,0 +1,69 @@
+# lib/hind/lsif/visitors/declaration_visitor.rb
+# frozen_string_literal: true
+
+module Hind
+  module LSIF
+    class DeclarationVisitor < Prism::Visitor
+      attr_reader :current_scope
+
+      def initialize(generator, file_path)
+        @generator = generator
+        @file_path = file_path
+        @current_scope = []
+      end
+
+      def visit_class_node(node)
+        @current_scope.push(node.constant_path.slice)
+        class_name = current_scope_name
+
+        @generator.register_declaration({
+          type: :class,
+          name: class_name,
+          node: node,
+          scope: @current_scope[0..-2].join('::'),
+          superclass: node.superclass&.slice
+        })
+
+        super
+        @current_scope.pop
+      end
+
+      def visit_module_node(node)
+        @current_scope.push(node.constant_path.slice)
+        module_name = current_scope_name
+
+        @generator.register_declaration({
+          type: :module,
+          name: module_name,
+          node: node,
+          scope: @current_scope[0..-2].join('::')
+        })
+
+        super
+        @current_scope.pop
+      end
+
+      def visit_constant_write_node(node)
+        return unless node.name
+
+        constant_name = node.name.to_s
+        qualified_name = @current_scope.empty? ? constant_name : "#{current_scope_name}::#{constant_name}"
+
+        @generator.register_declaration({
+          type: :constant,
+          name: qualified_name,
+          node: node,
+          scope: current_scope_name
+        })
+
+        super
+      end
+
+      private
+
+      def current_scope_name
+        @current_scope.join('::')
+      end
+    end
+  end
+end

data/lib/hind/lsif/visitors/reference_visitor.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Hind
+  module LSIF
+    class ReferenceVisitor < Prism::Visitor
+      attr_reader :current_scope
+
+      def initialize(generator, file_path)
+        @generator = generator
+        @file_path = file_path
+        @current_scope = []
+      end
+
+      def visit_constant_read_node(node)
+        return unless node.name
+
+        constant_name = node.name.to_s
+        qualified_name = @current_scope.empty? ? constant_name : "#{current_scope_name}::#{constant_name}"
+
+        @generator.register_reference({
+          type: :constant,
+          name: qualified_name,
+          node: node,
+          scope: current_scope_name
+        })
+
+        super
+      end
+
+      def visit_constant_path_node(node)
+        qualified_name = node.slice
+
+        @generator.register_reference({
+          type: :constant,
+          name: qualified_name,
+          node: node,
+          scope: current_scope_name
+        })
+
+        super
+      end
+
+      def visit_class_node(node)
+        @current_scope.push(node.constant_path.slice)
+        super
+        @current_scope.pop
+      end
+
+      def visit_module_node(node)
+        @current_scope.push(node.constant_path.slice)
+        super
+        @current_scope.pop
+      end
+
+      private
+
+      def current_scope_name
+        @current_scope.join('::')
+      end
+    end
+  end
+end

data/lib/hind/lsif.rb

@@ -4,7 +4,6 @@ require_relative 'lsif/global_state'
 require_relative 'lsif/edge'
 require_relative 'lsif/generator'
 require_relative 'lsif/vertex'
-require_relative 'lsif/visitor'
 
 module Hind
   module LSIF

data/lib/hind/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hind
-  VERSION = '0.1.5'
+  VERSION = '0.1.7'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: hind
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.7
 platform: ruby
 authors:
 - Aboobacker MK
 bindir: exe
 cert_chain: []
-date: 2025-02-09 00:00:00.000000000 Z
+date: 2025-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
@@ -111,7 +111,8 @@ files:
 - lib/hind/lsif/generator.rb
 - lib/hind/lsif/global_state.rb
 - lib/hind/lsif/vertex.rb
-- lib/hind/lsif/visitor.rb
+- lib/hind/lsif/visitors/declaration_visitor.rb
+- lib/hind/lsif/visitors/reference_visitor.rb
 - lib/hind/parser.rb
 - lib/hind/scip.rb
 - lib/hind/scip/generator.rb

data/lib/hind/lsif/visitor.rb

@@ -1,268 +0,0 @@
-# lib/hind/lsif/visitor.rb
-# frozen_string_literal: true
-
-module Hind
-  module LSIF
-    class Visitor
-      def initialize(generator)
-        @generator = generator
-        @current_scope = []
-      end
-
-      def visit(node)
-        return unless node
-
-        method_name = "visit_#{node.class.name.split("::").last.downcase}"
-        if respond_to?(method_name)
-          send(method_name, node)
-        else
-          visit_children(node)
-        end
-      end
-
-      def visit_children(node)
-        node.child_nodes.each { |child| visit(child) if child }
-      end
-
-      def visit_defnode(node)
-        # Handle method definitions
-        method_name = node.name.to_s
-        qualified_name = current_scope_name.empty? ? method_name : "#{current_scope_name}##{method_name}"
-
-        range_id = @generator.create_range(node.location, node.location)
-        result_set_id = @generator.emit_vertex('resultSet')
-        @generator.emit_edge('next', range_id, result_set_id)
-
-        def_result_id = @generator.emit_vertex('definitionResult')
-        @generator.emit_edge('textDocument/definition', result_set_id, def_result_id)
-        @generator.emit_edge('item', def_result_id, [range_id], 'definitions')
-
-        # Generate method signature for hover
-        sig = []
-        sig << "def #{qualified_name}"
-        sig << "(#{node.parameters.slice})" if node.parameters
-
-        hover_id = @generator.emit_vertex('hoverResult', {
-          contents: [{
-            language: 'ruby',
-            value: sig.join
-          }]
-        })
-        @generator.emit_edge('textDocument/hover', result_set_id, hover_id)
-
-        @generator.add_to_global_state(qualified_name, result_set_id, range_id)
-
-        visit_children(node)
-      end
-
-      def visit_classnode(node)
-        @current_scope.push(node.constant_path.slice)
-        class_name = current_scope_name
-
-        range_id = @generator.create_range(node.location, node.location)
-        result_set_id = @generator.emit_vertex('resultSet')
-        @generator.emit_edge('next', range_id, result_set_id)
-
-        def_result_id = @generator.emit_vertex('definitionResult')
-        @generator.emit_edge('textDocument/definition', result_set_id, def_result_id)
-        @generator.emit_edge('item', def_result_id, [range_id], 'definitions')
-
-        # Generate hover with inheritance info
-        hover = []
-        class_def = "class #{class_name}"
-        class_def += " < #{node.superclass.slice}" if node.superclass
-
-        hover << if node.superclass
-          "#{class_def}\n\nInherits from: #{node.superclass.slice}"
-        else
-          class_def
-        end
-
-        hover_id = @generator.emit_vertex('hoverResult', {
-          contents: [{
-            language: 'ruby',
-            value: hover.join("\n")
-          }]
-        })
-        @generator.emit_edge('textDocument/hover', result_set_id, hover_id)
-
-        @generator.add_to_global_state(class_name, result_set_id, range_id)
-
-        # Handle inheritance
-        visit_inheritance(node.superclass) if node.superclass
-
-        visit_children(node)
-        @current_scope.pop
-      end
-
-      def visit_modulenode(node)
-        @current_scope.push(node.constant_path.slice)
-        module_name = current_scope_name
-
-        range_id = @generator.create_range(node.location, node.location)
-        result_set_id = @generator.emit_vertex('resultSet')
-        @generator.emit_edge('next', range_id, result_set_id)
-
-        def_result_id = @generator.emit_vertex('definitionResult')
-        @generator.emit_edge('textDocument/definition', result_set_id, def_result_id)
-        @generator.emit_edge('item', def_result_id, [range_id], 'definitions')
-
-        hover_id = @generator.emit_vertex('hoverResult', {
-          contents: [{
-            language: 'ruby',
-            value: "module #{module_name}"
-          }]
-        })
-        @generator.emit_edge('textDocument/hover', result_set_id, hover_id)
-
-        @generator.add_to_global_state(module_name, result_set_id, range_id)
-
-        visit_children(node)
-        @current_scope.pop
-      end
-
-      def visit_callnode(node)
-        return unless node.name && node.location
-
-        method_name = node.name.to_s
-        qualified_names = []
-
-        # Try with current scope first
-        qualified_names << "#{current_scope_name}##{method_name}" unless current_scope_name.empty?
-
-        # Try with receiver's type if available
-        if node.receiver
-          case node.receiver
-          when Prism::ConstantReadNode
-            qualified_names << "#{node.receiver.name}##{method_name}"
-          when Prism::CallNode
-            # Handle method chaining
-            qualified_names << "#{node.receiver.name}##{method_name}" if node.receiver.name
-          when Prism::InstanceVariableReadNode
-            # Handle instance variable calls
-            qualified_names << "#{current_scope_name}##{method_name}" if current_scope_name
-          end
-        end
-
-        # Try as a standalone method
-        qualified_names << method_name
-
-        # Add references for matching qualified names
-        qualified_names.each do |qualified_name|
-          next unless @generator.global_state.result_sets[qualified_name]
-
-          range_id = @generator.create_range(node.location, node.location)
-          @generator.global_state.add_reference(qualified_name, @generator.metadata[:uri], range_id)
-          @generator.emit_edge('next', range_id, @generator.global_state.result_sets[qualified_name])
-          break # Stop after finding first match
-        end
-
-        visit_children(node)
-      end
-
-      def visit_constantreadnode(node)
-        return unless node.name
-
-        constant_name = node.name.to_s
-        qualified_name = @current_scope.empty? ? constant_name : "#{current_scope_name}::#{constant_name}"
-
-        return unless @generator.global_state.result_sets[qualified_name]
-
-        range_id = @generator.create_range(node.location, node.location)
-        @generator.global_state.add_reference(qualified_name, @generator.metadata[:uri], range_id)
-        @generator.emit_edge('next', range_id, @generator.global_state.result_sets[qualified_name])
-      end
-
-      def visit_constantwritenode(node)
-        return unless node.name
-
-        constant_name = node.name.to_s
-        qualified_name = @current_scope.empty? ? constant_name : "#{current_scope_name}::#{constant_name}"
-
-        range_id = @generator.create_range(node.location, node.location)
-        result_set_id = @generator.emit_vertex('resultSet')
-        @generator.emit_edge('next', range_id, result_set_id)
-
-        def_result_id = @generator.emit_vertex('definitionResult')
-        @generator.emit_edge('textDocument/definition', result_set_id, def_result_id)
-        @generator.emit_edge('item', def_result_id, [range_id], 'definitions')
-
-        hover_id = @generator.emit_vertex('hoverResult', {
-          contents: [{
-            language: 'ruby',
-            value: "#{qualified_name} = ..."
-          }]
-        })
-        @generator.emit_edge('textDocument/hover', result_set_id, hover_id)
-
-        @generator.add_to_global_state(qualified_name, result_set_id, range_id)
-
-        visit_children(node)
-      end
-
-      def visit_instancevariablereadnode(node)
-        return unless node.name && current_scope_name
-
-        var_name = node.name.to_s
-        qualified_name = "#{current_scope_name}##{var_name}"
-
-        return unless @generator.global_state.result_sets[qualified_name]
-
-        range_id = @generator.create_range(node.location, node.location)
-        @generator.global_state.add_reference(qualified_name, @generator.metadata[:uri], range_id)
-        @generator.emit_edge('next', range_id, @generator.global_state.result_sets[qualified_name])
-      end
-
-      def visit_instancevariablewritenode(node)
-        return unless node.name && current_scope_name
-
-        var_name = node.name.to_s
-        qualified_name = "#{current_scope_name}##{var_name}"
-
-        range_id = @generator.create_range(node.location, node.location)
-        result_set_id = @generator.emit_vertex('resultSet')
-        @generator.emit_edge('next', range_id, result_set_id)
-
-        def_result_id = @generator.emit_vertex('definitionResult')
-        @generator.emit_edge('textDocument/definition', result_set_id, def_result_id)
-        @generator.emit_edge('item', def_result_id, [range_id], 'definitions')
-
-        hover_id = @generator.emit_vertex('hoverResult', {
-          contents: [{
-            language: 'ruby',
-            value: "Instance variable #{var_name} in #{current_scope_name}"
-          }]
-        })
-        @generator.emit_edge('textDocument/hover', result_set_id, hover_id)
-
-        @generator.add_to_global_state(qualified_name, result_set_id, range_id)
-
-        visit_children(node)
-      end
-
-      private
-
-      def current_scope_name
-        @current_scope.join('::')
-      end
-
-      def visit_inheritance(node)
-        case node
-        when Prism::ConstantReadNode, Prism::ConstantPathNode
-          range_id = @generator.create_range(node.location, node.location)
-          qualified_name = case node
-          when Prism::ConstantReadNode
-            node.name.to_s
-          when Prism::ConstantPathNode
-            node.slice
-          end
-
-          return unless @generator.global_state.result_sets[qualified_name]
-
-          @generator.global_state.add_reference(qualified_name, @generator.metadata[:uri], range_id)
-          @generator.emit_edge('next', range_id, @generator.global_state.result_sets[qualified_name])
-        end
-      end
-    end
-  end
-end