hind 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66f58f99f053b938815d051ff6404a478a4f340178f74556ce6ab63f0a93c2e4
-  data.tar.gz: 02e04a6c88687f9baf37013fc216dc7df52b5fa6e81f60170cbb31146335c91b
+  metadata.gz: debf085e96a2d5683f8aac3870ab5c06ce0b28adc8dfa960227fb0a763defcee
+  data.tar.gz: 475b21bdbc4502c445a24be086e131c511f53972f113e7dda6e2b52eb03b16b1
 SHA512:
-  metadata.gz: 529d648a5f0677180c4c73daa8d316661f4b82b7bd4802318c8bb42a7ed7bd8d2ffb38b69a82a274483638ea7bc1c161ea9d6bb6f3c7f84e3ff75464a1968c75
-  data.tar.gz: dc734f7623cffa1c0cc6260627d14916e6e9809c3b06afcad1bd87015c8c32b8bbe979ed978abb922adc3af7a19c7c3099f3217c00016711260aacd5079fab6c
+  metadata.gz: da48ed207a58c99a9a544c2f5f2d0b3c88aecd7fa36ef7fc348064f925033ae33b7702c04d1147970a583b27a2031c5de7ca89b4b9d0aefb731ae0b3ffa93ce7
+  data.tar.gz: 88f86b97957a68ab50d153311d6d07a0ab0d99f39dfabe2409039ef86fc22af6f162419ddb926de58c938ebc9de165291c30e33556ac25db0d467ec1c450e610

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]
+      say "Found #{files.length} files to process", :green if options[: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])
-
-      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,41 +54,56 @@ 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]
+
+        # Write initial LSIF data (metadata and project vertices)
+        initial_data = generator.get_initial_data
+        if initial_data&.any?
+          say 'Writing initial LSIF data...', :cyan if options[:verbose]
+          output_file.puts(initial_data.map(&:to_json).join("\n"))
+        end
 
         # 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]
+
+        # Write declaration LSIF data next
+        if declaration_data[:lsif_data]&.any?
+          output_file.puts(declaration_data[:lsif_data].map(&:to_json).join("\n"))
+        end
+
+        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
           end
 
-          lsif_data = generator.process_file(
+          reference_lsif_data = generator.process_file(
             content: content,
             uri: relative_path
           )
-
-          output_file.puts(lsif_data.map(&:to_json).join("\n"))
+          output_file.puts(reference_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?
+        # Finalize and write cross-file references
+        say 'Processing cross-file references...', :cyan if options[:verbose]
+        final_references = generator.finalize_references
+        output_file.puts(final_references.map(&:to_json).join("\n"))
       end
     end
 
@@ -150,109 +124,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,8 +24,10 @@ module Hind
 
         @global_state = GlobalState.new
         @document_ids = {}
+        @current_document_id = nil
         @lsif_data = []
         @current_uri = nil
+        @last_vertex_id = @vertex_id
 
         initialize_project if metadata[:initial]
       end
@@ -33,30 +35,82 @@ 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 }
+        # Store the last used vertex ID and reset reference index
+        @last_vertex_id = @vertex_id
+        @last_reference_index = @lsif_data.length
+
+        {
+          declarations: @global_state.declarations,
+          lsif_data: @lsif_data
+        }
       end
 
       def process_file(params)
-        content = params[:content]
         @current_uri = params[:uri]
+        content = params[:content]
+
+        # Restore vertex ID from last declaration pass
+        @vertex_id = @last_vertex_id
+
+        @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
+        finalize_document_state
+
+        # Update last vertex ID
+        @last_vertex_id = @vertex_id
+
+        # Return only the new LSIF data since last call
+        result = @lsif_data[@last_reference_index..]
+        @last_reference_index = @lsif_data.length
+        result
+      end
+
+      def get_initial_data
+        @initial_data
+      end
+
+      def finalize_references
+        # Restore vertex ID
+        @vertex_id = @last_vertex_id
+        # Process all references to create definition results
+        @global_state.references.each do |qualified_name, references|
+          declaration = @global_state.declarations[qualified_name]
+          next unless declaration && declaration[:result_set_id]
+
+          # Create reference result for this symbol
+          ref_result_id = emit_vertex('referenceResult')
+          emit_edge('textDocument/references', declaration[:result_set_id], ref_result_id)
+
+          # Group references by document
+          references_by_doc = references.group_by { |ref| ref[:document_id] }
+
+          # Create item edges for each document's references
+          references_by_doc.each do |doc_id, refs|
+            emit_edge('item', ref_result_id, refs.map { |r| r[:range_id] }, 'references', doc_id)
+          end
+        end
+
         @lsif_data
       end
 
@@ -64,6 +118,10 @@ module Hind
         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 +130,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 +147,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
+        return unless declaration[:result_set_id]
 
-      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
-
-          # 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 +184,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 +197,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 +251,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 +267,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 +279,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 +286,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 +315,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}"