hind 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b3c0df71c84060e0417139c2d3458f1f889af0cb78b8323220ef67304b82c332
+  data.tar.gz: 8d707849d54508dfc120a47113552c87d216d5b69665dbee1e0f8477a625bfc0
+SHA512:
+  metadata.gz: 9238a787be39b18fe96da0ad5a311dbef75aebf3c178fb7c90d1618cf1fd4747d82c717cec3cde0720131cf5fe1e5d236d0d9bdde3c697ec5a45de333dd24b0e
+  data.tar.gz: 5327651b3056ab53c9fa6e22cbe86d5a94129fff76cc3a96747a5c27bb8774ba113e8e10008b828ed63c708e9dd34ac4c99d633347fef7a20d517d38ad400fb7

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Aboobacker MK
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+# Hind
+
+TODO: Delete this and the text below, and describe your gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/hind`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/hind.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/exe/hind

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require "bundler/setup"
+require "hind"
+require "hind/cli"
+
+Hind::CLI.start(ARGV)

data/lib/hind/cli.rb

@@ -0,0 +1,141 @@
+require 'thor'
+require 'json'
+require 'pathname'
+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'
+    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'
+    def lsif
+      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_lsif(files, options)
+        say "\nLSIF data has been written to: #{options[:output]}", :green if options[:verbose]
+      rescue StandardError => 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 StandardError => e
+        abort "Error generating SCIP: #{e.message}"
+      end
+    end
+
+    desc 'version', 'Show version'
+    def version
+      say "Hind version #{Hind::VERSION}"
+    end
+
+    private
+
+    def validate_directory(directory)
+      abort "Error: Directory '#{directory}' does not exist" unless Dir.exist?(directory)
+    end
+
+    def validate_output_file(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))
+    end
+
+    def find_files(directory, glob, exclude_patterns)
+      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
+      end
+
+      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|
+          if options[:verbose]
+            say "Processing file: #{file}", :cyan
+          end
+
+          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 StandardError => 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 StandardError => e
+        abort "Error loading config file: #{e.message}"
+      end
+    end
+  end
+end

data/lib/hind/lsif/edge.rb

@@ -0,0 +1,36 @@
+module Hind
+  module LSIF
+    class Edge
+      attr_reader :id, :label, :out_v, :in_v, :property, :document
+
+      def initialize(id, label, out_v, in_v, property = nil, document = nil)
+        @id = id
+        @label = label
+        @out_v = out_v
+        @in_v = in_v
+        @property = property
+        @document = document
+      end
+
+      def to_json
+        json = {
+          id: @id,
+          type: 'edge',
+          label: @label,
+          outV: @out_v
+        }
+
+        if @in_v.is_a?(Array)
+          json[:inVs] = @in_v
+        else
+          json[:inV] = @in_v
+        end
+
+        json[:property] = @property if @property
+        json[:document] = @document if @document
+
+        json
+      end
+    end
+  end
+end

data/lib/hind/lsif/generator.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require 'prism'
+require 'json'
+require 'uri'
+
+module Hind
+  module LSIF
+    class Generator
+      LSIF_VERSION = '0.4.3'
+
+      attr_reader :global_state, :document_id, :metadata
+
+      def initialize(metadata = {}, global_state = nil)
+        @vertex_id = metadata[:vertex_id] || 1
+        @metadata = {
+          language: 'ruby',
+          projectRoot: Dir.pwd
+        }.merge(metadata)
+
+        @global_state = global_state || GlobalState.new
+        @document_ids = {}
+        @lsif_data = []
+
+        initialize_project if metadata[:initial]
+      end
+
+      def generate(code, file_metadata = {})
+        @metadata = @metadata.merge(file_metadata)
+        setup_document
+
+        ast = Parser.new(code).parse
+        visitor = Visitor.new(self)
+        visitor.visit(ast)
+
+        finalize_document
+        update_cross_file_references
+
+        @lsif_data
+      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
+          }
+        })
+
+        file_path = File.join(@metadata[:projectRoot], @metadata[:uri])
+        @global_state.add_range(file_path, range_id)
+        range_id
+      end
+
+      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
+
+      def emit_edge(label, out_v, in_v, property = nil)
+        return unless out_v && valid_in_v?(in_v)
+
+        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
+      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)
+      end
+
+      private
+
+      def initialize_project
+        emit_vertex('metaData', {
+          version: LSIF_VERSION,
+          projectRoot: path_to_uri(@metadata[:projectRoot]),
+          positionEncoding: 'utf-16',
+          toolInfo: {
+            name: 'hind',
+            version: VERSION
+          }
+        })
+
+        @global_state.project_id = emit_vertex('project', { kind: 'ruby' })
+      end
+
+      def setup_document
+        file_path = File.join(@metadata[:projectRoot], @metadata[:uri])
+
+        @document_id = emit_vertex('document', {
+          uri: path_to_uri(file_path),
+          languageId: 'ruby'
+        })
+        @document_ids[file_path] = @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]
+
+        if ranges&.any?
+          emit_edge('contains', @document_id, ranges)
+        end
+      end
+
+      def update_cross_file_references
+        @global_state.references.each do |qualified_name, references|
+          definition = @global_state.definitions[qualified_name]
+          next unless definition
+
+          result_set_id = @global_state.result_sets[qualified_name]
+          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 << definition[:range_id]
+
+          # 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
+
+            emit_edge('item', ref_result_id, all_refs, 'references')
+          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
+        end
+      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)
+        normalized_path = path.gsub('\\', '/')
+        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

@@ -0,0 +1,30 @@
+module Hind
+  module LSIF
+    class GlobalState
+      attr_reader :result_sets, :definitions, :references, :ranges
+      attr_accessor :project_id
+
+      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
+      end
+
+      def add_range(file_path, range_id)
+        @ranges[file_path] ||= []
+        @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 }
+      end
+
+      def add_reference(qualified_name, file_path, range_id)
+        @references[qualified_name] ||= []
+        @references[qualified_name] << { file: file_path, range_id: range_id }
+      end
+    end
+  end
+end

data/lib/hind/lsif/vertex.rb

@@ -0,0 +1,31 @@
+module Hind
+  module LSIF
+    class Vertex
+      attr_reader :id, :label, :data
+
+      def initialize(id, label, data = nil)
+        @id = id
+        @label = label
+        @data = data
+      end
+
+      def to_json
+        json = {
+          id: @id,
+          type: 'vertex',
+          label: @label
+        }
+
+        if @data
+          if %w[hoverResult definitionResult referenceResult].include?(@label)
+            json[:result] = @data
+          else
+            json.merge!(@data)
+          end
+        end
+
+        json
+      end
+    end
+  end
+end

data/lib/hind/lsif/visitor.rb

@@ -0,0 +1,63 @@
+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)
+        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')
+
+        # Add hover information
+        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
+
+      # Additional visitor methods...
+
+      private
+
+      def current_scope_name
+        @current_scope.join('::')
+      end
+    end
+  end
+end

data/lib/hind/lsif.rb

@@ -0,0 +1,11 @@
+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
+  end
+end

data/lib/hind/parser.rb

@@ -0,0 +1,13 @@
+module Hind
+  class Parser
+    def initialize(code)
+      @code = code
+    end
+
+    def parse
+      result = Prism.parse(@code)
+      raise "Parse error: #{result.errors}" unless result.success?
+      result.value
+    end
+  end
+end

data/lib/hind/scip/generator.rb

@@ -0,0 +1,13 @@
+module Hind
+  module SCIP
+    class Generator
+      def initialize(metadata = {})
+        @metadata = metadata
+      end
+
+      def generate(code, file_metadata = {})
+        # SCIP generation implementation
+      end
+    end
+  end
+end

data/lib/hind/scip/visitor.rb

@@ -0,0 +1,14 @@
+module Hind
+  module SCIP
+    class Visitor
+      def initialize(generator)
+        @generator = generator
+        @current_scope = []
+      end
+
+      def visit(node)
+        # SCIP visitor implementation
+      end
+    end
+  end
+end

data/lib/hind/scip.rb

@@ -0,0 +1,4 @@
+module Hind
+  module SCIP
+  end
+end

data/lib/hind/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Hind
+  VERSION = "0.1.0"
+end

data/lib/hind.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "hind/version"
+require_relative "hind/lsif"
+require_relative "hind/scip"
+require_relative "hind/parser"
+
+module Hind
+  class Error < StandardError; end
+  # Your code goes here...
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: hind
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Aboobacker MK
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-02-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.19.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.19.0
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: A tool to generate LSIF and SCIP index files for Ruby codebases
+email:
+- aboobackervyd@gmail.com
+executables:
+- hind
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- exe/hind
+- lib/hind.rb
+- lib/hind/cli.rb
+- lib/hind/lsif.rb
+- lib/hind/lsif/edge.rb
+- lib/hind/lsif/generator.rb
+- lib/hind/lsif/global_state.rb
+- lib/hind/lsif/vertex.rb
+- lib/hind/lsif/visitor.rb
+- lib/hind/parser.rb
+- lib/hind/scip.rb
+- lib/hind/scip/generator.rb
+- lib/hind/scip/visitor.rb
+- lib/hind/version.rb
+homepage: https://github.com/tachyons/hind
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/tachyons/hind
+  source_code_uri: https://github.com/tachyons/hind
+  changelog_uri: https://github.com/tachyons/hind/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
+summary: LSIF and SCIP generator for Ruby
+test_files: []