hind 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66f58f99f053b938815d051ff6404a478a4f340178f74556ce6ab63f0a93c2e4
-  data.tar.gz: 02e04a6c88687f9baf37013fc216dc7df52b5fa6e81f60170cbb31146335c91b
+  metadata.gz: 65e6158fb36117206f66c5989febbd5c336f7b8e88aa3b4a241a7d2cac091fa1
+  data.tar.gz: 753d17f81c708b80ebac94b1e17c1cfa2c34e4ed5bc767f9e2daed525b7485ab
 SHA512:
-  metadata.gz: 529d648a5f0677180c4c73daa8d316661f4b82b7bd4802318c8bb42a7ed7bd8d2ffb38b69a82a274483638ea7bc1c161ea9d6bb6f3c7f84e3ff75464a1968c75
-  data.tar.gz: dc734f7623cffa1c0cc6260627d14916e6e9809c3b06afcad1bd87015c8c32b8bbe979ed978abb922adc3af7a19c7c3099f3217c00016711260aacd5079fab6c
+  metadata.gz: 649463b8b55e5016d822334667c1e61f6bc4fefa62230a5f7846f2b396f9ad467c8ff848d9637377c4851bda3d7bb068cc1a319a16d06b31a2269384bc6486c9
+  data.tar.gz: 0376aec80b6dbd5eba49244103d093a004e428e284e644b17109010a3175969f0df9eb261edc94fc60d071a8594a925aaa7ffa975af112c575b2781380e85beb

data/lib/hind/cli.rb

@@ -4,59 +4,30 @@ require 'thor'
 require 'json'
 require 'pathname'
 require 'fileutils'
-require 'yaml'
 
 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'
     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'
-    method_option :workers, type: :numeric, aliases: '-w', default: 1, desc: 'Number of parallel workers'
     def lsif
-      config = load_config(options[:config])
-      opts = config.merge(symbolize_keys(options))
+      validate_directory(options[:directory])
+      validate_output_file(options[:output], options[:force])
 
-      validate_directory(opts[:directory])
-      validate_output_file(opts[:output], opts[:force])
+      files = find_files(options[:directory], options[:glob], options[:exclude])
+      abort "No files found matching pattern '#{options[:glob]}'" if files.empty?
 
-      files = find_files(opts[:directory], opts[:glob], opts[:exclude])
-      abort "No files found matching pattern '#{opts[:glob]}'" if files.empty?
-
-      say "Found #{files.length} files to process", :green if opts[:verbose]
-
-      begin
-        generate_lsif(files, opts)
-        say "\nLSIF data has been written to: #{opts[:output]}", :green if opts[:verbose]
-      rescue StandardError => e
-        handle_error(e, opts[:verbose])
-      end
-    end
-
-    desc 'check', 'Check LSIF dump file for validity and provide insights'
-    method_option :file, type: :string, aliases: '-f', default: 'dump.lsif', desc: 'LSIF dump file to check'
-    method_option :json, type: :boolean, desc: 'Output results in JSON format'
-    method_option :strict, type: :boolean, desc: 'Treat warnings as errors'
-    def check
-      abort "Error: File '#{options[:file]}' does not exist" unless File.exist?(options[:file])
+      say "Found #{files.length} files to process", :green if options[:verbose]
 
       begin
-        checker = Hind::LSIF::Checker.new(options[:file])
-        results = checker.check
-
-        if options[:json]
-          puts JSON.pretty_generate(results)
-        else
-          print_check_results(results)
-        end
-
-        exit(1) if !results[:valid] || (options[:strict] && results[:warnings].any?)
-      rescue StandardError => e
+        generate_lsif(files, options)
+        say "\nLSIF data has been written to: #{options[:output]}", :green if options[:verbose]
+      rescue => e
         handle_error(e, options[:verbose])
       end
     end
@@ -66,18 +37,6 @@ module Hind
       say "Hind version #{Hind::VERSION}"
     end
 
-    desc 'init', 'Initialize Hind configuration file'
-    method_option :force, type: :boolean, aliases: '-f', desc: 'Overwrite existing configuration'
-    def init
-      config_file = '.hind.yml'
-      if File.exist?(config_file) && !options[:force]
-        abort "Configuration file already exists. Use --force to overwrite."
-      end
-
-      create_default_config(config_file)
-      say "Created configuration file: #{config_file}", :green
-    end
-
     private
 
     def generate_lsif(files, options)
@@ -95,24 +54,27 @@ module Hind
       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
-        file_contents[relative_path] = File.read(absolute_path)
-      rescue StandardError => e
-        warn "Warning: Failed to read file '#{file}': #{e.message}"
-        next
+          .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]
+        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", :cyan if options[:verbose]
-        say "Processing files...", :cyan if options[:verbose]
+        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
+        # Second pass: Process each file for references
         file_contents.each do |relative_path, content|
           if options[:verbose]
             say "Processing file: #{relative_path}", :cyan
@@ -125,11 +87,6 @@ module Hind
 
           output_file.puts(lsif_data.map(&:to_json).join("\n"))
         end
-
-        # Write cross-reference data
-        say "Finalizing cross-references...", :cyan if options[:verbose]
-        cross_refs = generator.finalize_cross_references
-        output_file.puts(cross_refs.map(&:to_json).join("\n")) if cross_refs&.any?
       end
     end
 
@@ -150,109 +107,17 @@ module Hind
       pattern = File.join(directory, glob)
       files = Dir.glob(pattern)
 
-      if exclude_patterns
-        exclude_patterns.each do |exclude|
-          files.reject! { |f| File.fnmatch?(exclude, f) }
-        end
+      exclude_patterns&.each do |exclude|
+        files.reject! { |f| File.fnmatch?(exclude, f) }
       end
 
       files
     end
 
-    def load_config(config_path)
-      return {} unless config_path && File.exist?(config_path)
-
-      begin
-        YAML.load_file(config_path) || {}
-      rescue StandardError => e
-        abort "Error loading config file: #{e.message}"
-      end
-    end
-
-    def create_default_config(config_file)
-      config = {
-        'directory' => '.',
-        'output' => 'dump.lsif',
-        'glob' => '**/*.rb',
-        'exclude' => [
-          'test/**/*',
-          'spec/**/*',
-          'vendor/**/*'
-        ],
-        'workers' => 1
-      }
-
-      File.write(config_file, config.to_yaml)
-    end
-
-    def print_check_results(results)
-      print_check_status(results[:valid])
-      print_check_errors(results[:errors])
-      print_check_warnings(results[:warnings])
-      print_check_statistics(results[:statistics])
-    end
-
-    def print_check_status(valid)
-      status = valid ? "✅ LSIF dump is valid" : "❌ LSIF dump contains errors"
-      say(status, valid ? :green : :red)
-      puts
-    end
-
-    def print_check_errors(errors)
-      return if errors.empty?
-
-      say "Errors:", :red
-      errors.each do |error|
-        say "  • #{error}", :red
-      end
-      puts
-    end
-
-    def print_check_warnings(warnings)
-      return if warnings.empty?
-
-      say "Warnings:", :yellow
-      warnings.each do |warning|
-        say "  • #{warning}", :yellow
-      end
-      puts
-    end
-
-    def print_check_statistics(stats)
-      say "Statistics:", :cyan
-      say "  Total Elements: #{stats[:total_elements]}"
-      say "  Vertices: #{stats[:vertices][:total]}"
-      say "  Edges: #{stats[:edges][:total]}"
-      say "  Vertex/Edge Ratio: #{stats[:vertex_to_edge_ratio]}"
-      puts
-
-      say "  Documents: #{stats[:documents]}"
-      say "  Ranges: #{stats[:ranges]}"
-      say "  Definitions: #{stats[:definitions]}"
-      say "  References: #{stats[:references]}"
-      say "  Hovers: #{stats[:hovers]}"
-      puts
-
-      say "  Vertex Types:", :cyan
-      stats[:vertices][:by_type].each do |type, count|
-        say "    #{type}: #{count}"
-      end
-      puts
-
-      say "  Edge Types:", :cyan
-      stats[:edges][:by_type].each do |type, count|
-        say "    #{type}: #{count}"
-      end
-    end
-
     def handle_error(error, verbose)
       message = "Error: #{error.message}"
       message += "\n#{error.backtrace.join("\n")}" if verbose
       abort message
     end
-
-    def symbolize_keys(hash)
-      hash.transform_keys(&:to_sym)
-    end
   end
 end

data/lib/hind/lsif/generator.rb

@@ -24,6 +24,7 @@ module Hind
 
         @global_state = GlobalState.new
         @document_ids = {}
+        @current_document_id = nil
         @lsif_data = []
         @current_uri = nil
 
@@ -33,37 +34,49 @@ module Hind
       def collect_declarations(files)
         files.each do |path, content|
           @current_uri = path
-          ast = Parser.new(content).parse
-          visitor = DeclarationVisitor.new(self, path)
-          visitor.visit(ast)
+          @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 }
+        {declarations: @global_state.declarations}
       end
 
       def process_file(params)
-        content = params[:content]
         @current_uri = params[:uri]
+        content = params[:content]
+
+        @document_id = nil
+        @current_document_id = nil
 
         setup_document
         ast = Parser.new(content).parse
 
-        # Process declarations first to update any missing ones
-        visitor = DeclarationVisitor.new(self, @current_uri)
-        visitor.visit(ast)
-
-        # Then process references
         visitor = ReferenceVisitor.new(self, @current_uri)
         visitor.visit(ast)
 
-        finalize_document
-        @lsif_data
+        result = @lsif_data
+        finalize_document_state
+        result
       end
 
       def register_declaration(declaration)
         return unless @current_uri && declaration[:node]
 
         qualified_name = declaration[:name]
+
+        setup_document if @document_id.nil?
+        current_doc_id = @document_id
+
         range_id = create_range(declaration[:node].location, declaration[:node].location)
         return unless range_id
 
@@ -72,7 +85,8 @@ module Hind
 
         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')
+
+        emit_edge('item', def_result_id, [range_id], 'definitions', current_doc_id)
 
         hover_content = generate_hover_content(declaration)
         hover_id = emit_vertex('hoverResult', {
@@ -88,74 +102,28 @@ module Hind
           scope: declaration[:scope],
           file: @current_uri,
           range_id: range_id,
-          result_set_id: result_set_id
+          result_set_id: result_set_id,
+          document_id: current_doc_id
         }.merge(declaration))
+
+        result_set_id
       end
 
       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]]
-        @global_state.add_reference(reference[:name], @current_uri, range_id)
-        emit_edge('next', range_id, declaration[:result_set_id])
-      end
-
-      def finalize_cross_references
-        cross_ref_data = []
-
-        @global_state.references.each do |qualified_name, references|
-          declaration = @global_state.declarations[qualified_name]
-          next unless declaration
-
-          result_set_id = declaration[:result_set_id]
-          next unless result_set_id
-
-          ref_result_id = emit_vertex('referenceResult')
-          emit_edge('textDocument/references', result_set_id, ref_result_id)
-
-          # Collect all reference range IDs
-          all_refs = references.map { |ref| ref[:range_id] }
-          all_refs << declaration[:range_id] if declaration[:range_id]
-
-          # Group references by document
-          references.group_by { |ref| ref[:file] }.each do |file_path, file_refs|
-            document_id = @document_ids[file_path]
-            next unless document_id
-
-            cross_ref_data << {
-              id: @vertex_id,
-              type: 'edge',
-              label: 'item',
-              outV: ref_result_id,
-              inVs: all_refs,
-              document: document_id,
-              property: 'references'
-            }
-            @vertex_id += 1
-          end
+        return unless declaration[:result_set_id]
 
-          # Handle document containing the definition
-          def_file = declaration[:file]
-          def_document_id = @document_ids[def_file]
-          if def_document_id && references.none? { |ref| ref[:file] == def_file }
-            cross_ref_data << {
-              id: @vertex_id,
-              type: 'edge',
-              label: 'item',
-              outV: ref_result_id,
-              inVs: all_refs,
-              document: def_document_id,
-              property: 'references'
-            }
-            @vertex_id += 1
-          end
-        end
-
-        cross_ref_data
+        @global_state.add_reference(reference[:name], @current_uri, range_id, current_doc_id)
+        emit_edge('next', range_id, declaration[:result_set_id])
       end
 
       private
@@ -171,10 +139,11 @@ module Hind
           }
         })
 
-        @global_state.project_id = emit_vertex('project', { kind: 'ruby' })
+        @global_state.project_id = emit_vertex('project', {kind: 'ruby'})
       end
 
       def setup_document
+        return if @document_id
         return unless @current_uri
 
         file_path = File.join(@metadata[:projectRoot], @current_uri)
@@ -183,17 +152,19 @@ module Hind
           uri: path_to_uri(file_path),
           languageId: 'ruby'
         })
+
         @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
-        return unless @current_uri
+      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)
+          emit_edge('contains', @document_id, ranges, nil, @document_id)
         end
       end
 
@@ -235,7 +206,7 @@ module Hind
         @vertex_id - 1
       end
 
-      def emit_edge(label, out_v, in_v, property = nil)
+      def emit_edge(label, out_v, in_v, property = nil, doc_id = nil)
         return unless out_v && valid_in_v?(in_v)
 
         edge = {
@@ -251,8 +222,10 @@ module Hind
           edge[:inV] = in_v
         end
 
-        edge[:document] = @document_id if label == 'item'
-        edge[:property] = property if property
+        if label == 'item'
+          edge[:document] = doc_id || @current_document_id
+          edge[:property] = property if property
+        end
 
         @lsif_data << edge
         @vertex_id += 1
@@ -261,11 +234,6 @@ module Hind
 
       def generate_hover_content(declaration)
         case declaration[:type]
-        when :method
-          sig = []
-          sig << "def #{declaration[:name]}"
-          sig << "(#{declaration[:params]})" if declaration[:params]
-          sig.join
         when :class
           hover = ["class #{declaration[:name]}"]
           hover << " < #{declaration[:superclass]}" if declaration[:superclass]
@@ -273,7 +241,8 @@ module Hind
         when :module
           "module #{declaration[:name]}"
         when :constant
-          "#{declaration[:name]} = ..."
+          value_info = declaration[:node].value ? " = #{declaration[:node].value.inspect}" : ''
+          "#{declaration[:name]}#{value_info}"
         else
           declaration[:name].to_s
         end
@@ -301,7 +270,7 @@ module Hind
 
       def path_to_uri(path)
         return nil unless path
-        normalized_path = path.gsub('\\', '/')
+        normalized_path = path.tr('\\', '/')
         normalized_path = normalized_path.sub(%r{^file://}, '')
         absolute_path = File.expand_path(normalized_path)
         "file://#{absolute_path}"

data/lib/hind/lsif/global_state.rb

@@ -13,10 +13,6 @@ module Hind
         @result_sets = {}     # {qualified_name => result_set_id}
         @ranges = {}          # {file_path => [range_ids]}
         @project_id = nil
-
-        # Method visibility tracking
-        @visibility_stack = [] # Stack of method visibility states per scope
-        @current_visibility = :public
       end
 
       def add_declaration(qualified_name, data)
@@ -24,12 +20,12 @@ module Hind
         @result_sets[qualified_name] = data[:result_set_id] if data[:result_set_id]
       end
 
-      def add_reference(qualified_name, file_path, range_id, type = :reference)
+      def add_reference(qualified_name, file_path, range_id, document_id)
         @references[qualified_name] ||= []
         @references[qualified_name] << {
           file: file_path,
           range_id: range_id,
-          type: type
+          document_id: document_id
         }
       end
 
@@ -58,98 +54,31 @@ module Hind
         @ranges[file_path] || []
       end
 
-      def push_visibility_scope(visibility = :public)
-        @visibility_stack.push(@current_visibility)
-        @current_visibility = visibility
-      end
-
-      def pop_visibility_scope
-        @current_visibility = @visibility_stack.pop || :public
-      end
-
-      def current_visibility
-        @current_visibility
-      end
-
-      def get_declaration_in_scope(name, scope)
-        # Try exact scope first
-        qualified_name = scope.empty? ? name : "#{scope}::#{name}"
-        return qualified_name if has_declaration?(qualified_name)
-
-        # Try parent scopes
-        scope_parts = 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
-
-        # Try top level
-        has_declaration?(name) ? name : nil
-      end
-
-      def get_method_declaration(method_name, scope, instance_method = true)
-        separator = instance_method ? '#' : '.'
-        qualified_name = scope.empty? ? method_name : "#{scope}#{separator}#{method_name}"
-
-        return qualified_name if has_declaration?(qualified_name)
-
-        # For instance methods, try to find in superclass chain
-        if instance_method && !scope.empty?
-          current_scope = scope
-          while (class_data = @declarations[current_scope])
-            break unless class_data[:type] == :class && class_data[:superclass]
-
-            superclass = class_data[:superclass]
-            superclass_method = "#{superclass}#{separator}#{method_name}"
-            return superclass_method if has_declaration?(superclass_method)
-
-            current_scope = superclass
-          end
-        end
-
-        nil
-      end
-
       def find_constant_declaration(name, current_scope)
         return name if has_declaration?(name)
 
-        # Try with current scope
         if current_scope && !current_scope.empty?
           qualified_name = "#{current_scope}::#{name}"
           return qualified_name if has_declaration?(qualified_name)
 
-          # Try parent scopes
           scope_parts = current_scope.split('::')
           while scope_parts.any?
             scope_parts.pop
-            qualified_name = scope_parts.empty? ? name : "#{scope_parts.join('::')}::#{name}"
+            qualified_name = scope_parts.empty? ? name : "#{scope_parts.join("::")}::#{name}"
             return qualified_name if has_declaration?(qualified_name)
           end
         end
 
-        # Try top level
         has_declaration?(name) ? name : nil
       end
 
-      def get_instance_variable_scope(var_name, current_scope)
-        return nil unless current_scope
-        "#{current_scope}##{var_name}"
-      end
-
-      def get_class_variable_scope(var_name, current_scope)
-        return nil unless current_scope
-        "#{current_scope}::#{var_name}"
-      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,
-          reference_types: reference_types_count
+          declaration_types: declaration_types_count
         }
       end
 
@@ -160,12 +89,6 @@ module Hind
           counts[decl[:type]] += 1
         end
       end
-
-      def reference_types_count
-        @references.values.flatten.each_with_object(Hash.new(0)) do |ref, counts|
-          counts[ref[:type]] += 1
-        end
-      end
     end
   end
 end

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

@@ -10,16 +10,12 @@ module Hind
         @generator = generator
         @file_path = file_path
         @current_scope = []
-        @current_visibility = :public
-        @visibility_stack = []
-        @in_singleton_class = false
       end
 
       def visit_class_node(node)
         @current_scope.push(node.constant_path.slice)
         class_name = current_scope_name
 
-        # Register class declaration
         @generator.register_declaration({
           type: :class,
           name: class_name,
@@ -28,10 +24,7 @@ module Hind
           superclass: node.superclass&.slice
         })
 
-        # Process the class body with proper scope and visibility
-        push_visibility(:public)
         super
-        pop_visibility
         @current_scope.pop
       end
 
@@ -46,32 +39,10 @@ module Hind
           scope: @current_scope[0..-2].join('::')
         })
 
-        push_visibility(:public)
         super
-        pop_visibility
         @current_scope.pop
       end
 
-      def visit_def_node(node)
-        method_name = node.name.to_s
-        # Use '#' for instance methods
-        qualified_name = @in_singleton_class ?
-          "#{current_scope_name}.#{method_name}" :
-          "#{current_scope_name}##{method_name}"
-
-        @generator.register_declaration({
-          type: :method,
-          name: qualified_name,
-          node: node,
-          scope: current_scope_name,
-          visibility: current_visibility,
-          params: node.parameters&.slice,
-          instance_method: !@in_singleton_class
-        })
-
-        super
-      end
-
       def visit_constant_write_node(node)
         return unless node.name
 
@@ -88,152 +59,11 @@ module Hind
         super
       end
 
-      def visit_singleton_class_node(node)
-        if node.expression.is_a?(Prism::SelfNode)
-          # class << self
-          @in_singleton_class = true
-          super
-          @in_singleton_class = false
-        else
-          # Process regular singleton class
-          super
-        end
-      end
-
-      def visit_call_node(node)
-        method_name = node.name.to_s
-        case method_name
-        when 'private', 'protected', 'public'
-          handle_visibility_method(node)
-        when 'attr_reader', 'attr_writer', 'attr_accessor'
-          handle_attribute_method(node)
-        end
-
-        super
-      end
-
-      def visit_class_variable_write_node(node)
-        return unless node.name
-
-        var_name = node.name.to_s
-        qualified_name = "#{current_scope_name}::#{var_name}"
-
-        @generator.register_declaration({
-          type: :class_variable,
-          name: qualified_name,
-          node: node,
-          scope: current_scope_name
-        })
-
-        super
-      end
-
-      def visit_instance_variable_write_node(node)
-        return unless node.name && current_scope_name
-
-        var_name = node.name.to_s
-        qualified_name = "#{current_scope_name}##{var_name}"
-
-        @generator.register_declaration({
-          type: :instance_variable,
-          name: qualified_name,
-          node: node,
-          scope: current_scope_name
-        })
-
-        super
-      end
-
       private
 
       def current_scope_name
         @current_scope.join('::')
       end
-
-      def current_visibility
-        @current_visibility
-      end
-
-      def push_visibility(visibility)
-        @visibility_stack.push(@current_visibility)
-        @current_visibility = visibility
-      end
-
-      def pop_visibility
-        @current_visibility = @visibility_stack.pop || :public
-      end
-
-      def handle_visibility_method(node)
-        visibility = node.name.to_sym
-
-        if node.arguments&.arguments&.empty?
-          # Global visibility change
-          @current_visibility = visibility
-        elsif node.arguments
-          # Per-method visibility change
-          node.arguments.arguments.each do |arg|
-            next unless arg.is_a?(Prism::SymbolNode) || arg.is_a?(Prism::StringNode)
-
-            method_name = arg.value.to_s
-            qualified_name = "#{current_scope_name}##{method_name}"
-
-            if @generator.global_state.has_declaration?(qualified_name)
-              @generator.global_state.get_declaration(qualified_name)[:visibility] = visibility
-            end
-          end
-        end
-      end
-
-      def handle_attribute_method(node)
-        return unless node.arguments
-
-        attr_type = node.name.to_s
-        node.arguments.arguments.each do |arg|
-          next unless arg.respond_to?(:value)
-
-          attr_name = arg.value.to_s
-          register_attribute(attr_name, attr_type)
-        end
-      end
-
-      def register_attribute(attr_name, attr_type)
-        base_name = "#{current_scope_name}##{attr_name}"
-
-        # Register reader method if applicable
-        if %w[attr_reader attr_accessor].include?(attr_type)
-          @generator.register_declaration({
-            type: :method,
-            name: base_name,
-            node: nil, # Synthetic node
-            scope: current_scope_name,
-            visibility: current_visibility,
-            synthetic: true,
-            kind: :reader
-          })
-        end
-
-        # Register writer method if applicable
-        if %w[attr_writer attr_accessor].include?(attr_type)
-          @generator.register_declaration({
-            type: :method,
-            name: "#{base_name}=",
-            node: nil, # Synthetic node
-            scope: current_scope_name,
-            visibility: current_visibility,
-            synthetic: true,
-            kind: :writer
-          })
-        end
-
-        # Register the instance variable
-        @generator.register_declaration({
-          type: :instance_variable,
-          name: "@#{attr_name}",
-          node: nil, # Synthetic node
-          scope: current_scope_name,
-          synthetic: true
-        })
-      end
     end
   end
 end

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

@@ -1,4 +1,3 @@
-# lib/hind/lsif/visitors/reference_visitor.rb
 # frozen_string_literal: true
 
 module Hind
@@ -12,27 +11,6 @@ module Hind
         @current_scope = []
       end
 
-      # Method calls
-      def visit_call_node(node)
-        return unless node.name && node.location
-
-        method_name = node.name.to_s
-        qualified_names = generate_qualified_names_for_call(node)
-
-        qualified_names.each do |qualified_name|
-          @generator.register_reference({
-            type: :method,
-            name: qualified_name,
-            node: node,
-            scope: current_scope_name,
-            call_type: :instance_method
-          })
-        end
-
-        super
-      end
-
-      # Class/module references
       def visit_constant_read_node(node)
         return unless node.name
 
@@ -49,7 +27,6 @@ module Hind
         super
       end
 
-      # Constant path references (e.g., A::B::C)
       def visit_constant_path_node(node)
         qualified_name = node.slice
 
@@ -63,87 +40,6 @@ module Hind
         super
       end
 
-      # Instance variable references
-      def visit_instance_variable_read_node(node)
-        return unless node.name && current_scope_name
-
-        var_name = node.name.to_s
-        qualified_name = "#{current_scope_name}##{var_name}"
-
-        @generator.register_reference({
-          type: :instance_variable,
-          name: qualified_name,
-          node: node,
-          scope: current_scope_name
-        })
-
-        super
-      end
-
-      # Class variable references
-      def visit_class_variable_read_node(node)
-        return unless node.name && current_scope_name
-
-        var_name = node.name.to_s
-        qualified_name = "#{current_scope_name}::#{var_name}"
-
-        @generator.register_reference({
-          type: :class_variable,
-          name: qualified_name,
-          node: node,
-          scope: current_scope_name
-        })
-
-        super
-      end
-
-      # Singleton method calls (class methods)
-      def visit_constant_path_call_node(node)
-        return unless node.name
-
-        method_name = node.name.to_s
-        receiver_name = node.receiver.slice
-        qualified_name = "#{receiver_name}.#{method_name}"
-
-        @generator.register_reference({
-          type: :method,
-          name: qualified_name,
-          node: node,
-          scope: current_scope_name,
-          call_type: :class_method
-        })
-
-        super
-      end
-
-      # Super method calls
-      def visit_super_node(node)
-        return unless current_scope_name
-
-        # Extract current method name from scope
-        current_method = current_method_name
-        return unless current_method
-
-        # Try to find the superclass method
-        if in_class_scope?
-          superclass = find_superclass
-          if superclass
-            qualified_name = "#{superclass}##{current_method}"
-
-            @generator.register_reference({
-              type: :method,
-              name: qualified_name,
-              node: node,
-              scope: current_scope_name,
-              call_type: :super
-            })
-          end
-        end
-
-        super
-      end
-
-      # Track class/module scope
       def visit_class_node(node)
         @current_scope.push(node.constant_path.slice)
         super
@@ -161,61 +57,6 @@ module Hind
       def current_scope_name
         @current_scope.join('::')
       end
-
-      def generate_qualified_names_for_call(node)
-        qualified_names = []
-        method_name = node.name.to_s
-
-        # 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::ConstantPathNode
-            qualified_names << "#{node.receiver.slice}##{method_name}"
-          when Prism::CallNode
-            # Method chaining - try both instance and class methods
-            if node.receiver.name
-              qualified_names << "#{node.receiver.name}##{method_name}"
-              qualified_names << "#{node.receiver.name}.#{method_name}"
-            end
-          when Prism::InstanceVariableReadNode
-            # Instance variable calls - try current class context
-            qualified_names << "#{current_scope_name}##{method_name}" if current_scope_name
-          end
-        end
-
-        # Try as a standalone method
-        qualified_names << method_name
-
-        # Add potential class method variant
-        qualified_names << "#{current_scope_name}.#{method_name}" unless current_scope_name.empty?
-
-        qualified_names.uniq
-      end
-
-      def current_method_name
-        # Try to find the nearest method node in the AST
-        # This is a simplified version - you might need to enhance this
-        # based on your specific needs
-        "current_method"
-      end
-
-      def in_class_scope?
-        # Check if we're currently in a class definition
-        !@current_scope.empty? && @generator.global_state.declarations[@current_scope.last]&.[](:type) == :class
-      end
-
-      def find_superclass
-        return unless in_class_scope?
-
-        current_class = @current_scope.last
-        class_declaration = @generator.global_state.declarations[current_class]
-        class_declaration&.[](:superclass)
-      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.6'
+  VERSION = '0.1.7'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hind
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Aboobacker MK
@@ -111,7 +111,6 @@ 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

data/lib/hind/lsif/visitor.rb

@@ -1,255 +0,0 @@
-# frozen_string_literal: true
-
-module Hind
-  module LSIF
-    class Visitor < Prism::Visitor
-      def initialize(generator)
-        @generator = generator
-        @current_scope = []
-      end
-
-      def visit_def_node(node)
-        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)
-
-        super
-      end
-
-      def visit_class_node(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
-
-        super
-        @current_scope.pop
-      end
-
-      def visit_module_node(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)
-
-        super
-        @current_scope.pop
-      end
-
-      def visit_call_node(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.type
-          when :constant_read
-            qualified_names << "#{node.receiver.name}##{method_name}"
-          when :call
-            # Handle method chaining
-            qualified_names << "#{node.receiver.name}##{method_name}" if node.receiver.name
-          when :instance_variable_read
-            # 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
-
-        super
-      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}"
-
-        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])
-
-        super
-      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}"
-
-        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)
-
-        super
-      end
-
-      def visit_instance_variable_read_node(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])
-
-        super
-      end
-
-      def visit_instance_variable_write_node(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)
-
-        super
-      end
-
-      private
-
-      def current_scope_name
-        @current_scope.join('::')
-      end
-
-      def visit_inheritance(node)
-        case node.type
-        when :constant_read_node, :constant_path_node
-          range_id = @generator.create_range(node.location, node.location)
-          qualified_name = case node.type
-          when :constant_read_node
-            node.name.to_s
-          when :constant_path_node
-            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