rubylens 0.2.0 → 0.2.1

data/lib/rubylens/index/rubydex_adapter.rb

@@ -2,65 +2,75 @@
 
 require "rubydex"
 require "set"
-require_relative "../model/dependency_aggregation"
+require_relative "constant_reference_collector"
+require_relative "declaration_collector"
+require_relative "location_index"
 require_relative "rspec_extractor"
-require_relative "source_path"
 
 module RubyLens
   module Index
+    # Drives one Rubydex indexing run over the manifest and assembles the
+    # snapshot payload from what the collectors return.
+    #
+    # The snapshot is the privacy boundary: every namespace and dependency star
+    # leaves here as a row of integers, and the only strings that survive are
+    # namespace names, package names, and the project name.
     class RubydexAdapter
-      TEST_SEGMENTS = %w[test tests spec specs feature features].freeze
-      CONSTANT_REFERENCE_LINK_LIMIT = 1_024
-      CONSTANT_REFERENCE_ATTRIBUTION_LIMIT = CONSTANT_REFERENCE_LINK_LIMIT * 2
-
-      ReferenceSummary = Data.define(:inbound_counts, :links)
+      SCHEMA = "rubylens.snapshot.v9"
+      RSPEC_ROW = [0, 1, *Array.new(11, 0)].freeze
 
+      # The manifest is duck-typed: production passes a Manifest, tests pass
+      # stubs, and `index` probes it with respond_to? for the optional parts.
+      #
+      #: (untyped manifest) -> void
       def initialize(manifest)
         @manifest = manifest
-        @source_path_cache = {}
-        @workspace_location_cache = {}
-        @definition_scope_by_uri = {}
-        @package_index_by_uri = {}
-        @indexed_package_document_paths = Set.new
+        @locations = LocationIndex.new(manifest)
       end
 
+      #: () -> Hash[String, untyped]
       def index
         graph = Rubydex::Graph.new(workspace_path: @manifest.root.to_s)
         index_errors = graph.index_all(@manifest.files)
-        @indexed_package_document_paths, documents_with_paths = resolve_documents(graph)
+        # Documents resolve before `resolve` so package attribution sees exactly
+        # the documents Rubydex accepted, not the paths the manifest offered.
+        documents_with_paths = @locations.resolve_documents(graph)
         graph.resolve
         integrity_failures = graph.check_integrity
-        collected = collect_declarations(graph.declarations)
+
+        collected = DeclarationCollector.new(manifest: @manifest, locations: @locations).call(graph.declarations)
         rspec = RSpecExtractor.new(
           graph: graph,
           manifest: @manifest,
-          package_document_paths: @indexed_package_document_paths,
+          package_document_paths: @locations.package_document_paths,
           documents_with_paths: documents_with_paths,
         ).call
-        workspace = workspace_namespaces(
-          collected.fetch(:workspace_records),
-          rspec.groups,
-          collected.fetch(:workspace_definition_ranges),
-        )
-        reference_summary = workspace_reference_summary(
-          graph,
-          workspace,
-          collected.fetch(:dependency_ordinal_by_name),
+
+        namespaces = collected.namespaces
+        namespace_names = namespaces.map(&:name) + rspec.groups
+        references = ConstantReferenceCollector.new(locations: @locations).call(
+          graph: graph,
+          namespaces: namespaces,
+          definition_ranges: collected.definition_ranges,
+          ordinal_by_name: ordinal_by_name(namespaces),
+          dependency_ordinal_by_name: collected.dependency_ordinal_by_name,
+          namespace_count: namespace_names.length,
         )
-        category_stats = collected.fetch(:category_stats)
+
+        category_stats = collected.category_stats
         category_stats.fetch("tests")[0] += rspec.groups.length
         category_stats.fetch("tests")[2] += rspec.method_count
 
         {
-          "schema" => "rubylens.snapshot.v9",
+          "schema" => SCHEMA,
           "project_name" => project_name,
-          "namespace_names" => workspace.fetch(:namespace_names),
-          "namespaces" => build_workspace_rows(workspace, reference_summary.inbound_counts),
-          "constant_reference_links" => reference_summary.links,
+          "namespace_names" => namespace_names,
+          "namespaces" => namespace_rows(namespaces, references.inbound_counts, rspec.groups.length),
+          "constant_reference_links" => references.links,
           "category_stats" => category_stats,
-          "dependency_signal_maxima" => collected.fetch(:dependency_signal_maxima),
-          "packages" => build_package_rows(collected.fetch(:dependency_packages)),
-          "dependency_systems" => build_dependency_system_rows,
+          "dependency_signal_maxima" => collected.dependency_signal_maxima,
+          "packages" => package_rows(collected.dependency_packages),
+          "dependency_systems" => dependency_system_rows,
           "dependency_warnings" => @manifest.respond_to?(:dependency_warnings) ? @manifest.dependency_warnings : [],
           "warning_counts" => {
             "manifest" => @manifest.warnings.length,
@@ -72,162 +82,86 @@ module RubyLens
 
       private
 
-      def collect_declarations(declarations)
-        records = []
-        category_stats = { "core" => Array.new(4, 0), "tests" => Array.new(4, 0) }
-        aggregation = Model::DependencyAggregation.new(package_count: @manifest.packages.length)
-        workspace_definition_ranges = Hash.new { |hash, uri| hash[uri] = [] }
-        dependency_positions = {}
-
-        declarations.each do |declaration|
-          name = declaration.name
-          next unless model_eligible_declaration?(declaration, name)
-
-          is_namespace = declaration.is_a?(Rubydex::Namespace)
-          construct_index = ruby_construct_index(declaration)
-          workspace_count, tests_only, canonical_site_keys, canonical_scope, package_site_keys =
-            summarize_definitions(declaration, is_namespace)
-          reference_count = safe_length(declaration, :references) if package_site_keys
-
-          if canonical_site_keys
-            canonical_site_keys = canonical_site_keys.uniq if canonical_site_keys.length > 1
-            ordinal = records.length
-            canonical_site_keys.each do |uri, start_line, start_column, end_line, end_column|
-              workspace_definition_ranges[uri] << [start_line, start_column, end_line, end_column, ordinal]
-            end
-            records << [declaration, canonical_site_keys.length, canonical_scope, name]
-          end
-          if construct_index && workspace_count.positive?
-            category_stats.fetch(tests_only ? "tests" : "core")[construct_index] += 1
-          end
-          collect_dependency_declaration(
-            aggregation,
-            dependency_positions,
-            declaration,
-            name,
-            is_namespace,
-            construct_index,
-            package_site_keys,
-            reference_count,
-          )
-        end
-
-        dependency_packages = aggregation.packages
-        dependency_offsets = []
-        offset = 0
-        dependency_packages.each do |package|
-          dependency_offsets << offset
-          offset += package.fetch(:declarations).length
-        end
-        dependency_ordinal_by_name = dependency_positions.transform_values! do |position|
-          package_index, local_index = position
-          dependency_offsets.fetch(package_index) + local_index
-        end
-
-        {
-          workspace_records: records,
-          workspace_definition_ranges:,
-          category_stats:,
-          dependency_packages:,
-          dependency_signal_maxima: aggregation.signal_maxima,
-          dependency_ordinal_by_name: dependency_ordinal_by_name.freeze,
-        }
-      end
-
-      # One pass over a declaration's definitions gathers everything the
-      # collectors need, so each definition's location and its per-URI
-      # workspace/scope/package answers cross the Rubydex boundary once.
-      # Canonical site keys and package site keys stay nil until a definition
-      # actually contributes to them, since most declarations produce neither.
-      def summarize_definitions(declaration, is_namespace)
-        workspace_count = 0
-        tests_seen = false
-        core_seen = false
-        canonical_tests_seen = false
-        canonical_core_seen = false
-        canonical_site_keys = nil
-        package_site_keys = nil
-
-        declaration.definitions.each do |definition|
-          location = definition.location
-          site_key = nil
-          if workspace_location?(location)
-            workspace_count += 1
-            scope = definition_scope(location.uri)
-            if scope == 1
-              tests_seen = true
-            elsif scope
-              core_seen = true
-            end
-            if is_namespace && canonical_namespace_definition?(declaration, definition)
-              (canonical_site_keys ||= []) << (site_key = location.comparable_values)
-              if scope == 1
-                canonical_tests_seen = true
-              elsif scope
-                canonical_core_seen = true
-              end
-            end
-          end
-          package_index = package_index_for_location(location)
-          if package_index
-            ((package_site_keys ||= {})[package_index] ||= []) << (site_key || location.comparable_values)
-          end
-        end
-
-        canonical_scope = canonical_tests_seen ? (canonical_core_seen ? 2 : 1) : 0
-        [workspace_count, tests_seen && !core_seen, canonical_site_keys, canonical_scope, package_site_keys]
-      end
-
-      def workspace_namespaces(records, rspec_groups, definition_ranges = {})
-        namespace_names = []
-        ordinal_by_name = {}
-        records.each_with_index do |record, index|
-          name = record.fetch(3)
-          namespace_names << name
-          ordinal_by_name[name] = index
-        end
-        {
-          records: records,
-          definition_ranges: definition_ranges,
-          rspec_groups: rspec_groups,
-          namespace_names: namespace_names + rspec_groups,
-          ordinal_by_name: ordinal_by_name,
-        }
-      end
-
-      def build_workspace_rows(workspace, inbound_references)
-        ordinal_by_name = workspace.fetch(:ordinal_by_name)
-        rows = workspace.fetch(:records).each_with_index.map do |record, index|
-          declaration, sites, scope, name = record
+      #: (Array[DeclarationCollector::Namespace]) -> Hash[String, Integer]
+      def ordinal_by_name(namespaces)
+        ordinals = {}
+        namespaces.each_with_index { |namespace, index| ordinals[namespace.name] = index }
+        ordinals
+      end
+
+      #: (Array[DeclarationCollector::Namespace], Hash[Integer, Integer], Integer) -> Array[Array[Integer]]
+      def namespace_rows(namespaces, inbound_counts, rspec_group_count)
+        drawn_names = ordinal_by_name(namespaces)
+        rows = namespaces.each_with_index.map do |namespace, index|
+          declaration = namespace.declaration
+          sites = namespace.definition_sites
+          # A namespace only earns a row through a class or module definition,
+          # so its own construct is exactly this kind.
+          kind = declaration.is_a?(Rubydex::Class) ? DeclarationCollector::CLASS : DeclarationCollector::MODULE
           descendants = declaration.descendants.count do |descendant|
-            descendant_name = descendant.name
-            descendant_name != name && ordinal_by_name.key?(descendant_name)
+            name = descendant.name
+            name != namespace.name && drawn_names.key?(name)
           end
-          member_count, ruby_counts, instance_variable_count = member_statistics(
+          members, ruby_counts, instance_variables = member_statistics(
             declaration,
-            count_instance_variables: declaration.is_a?(Rubydex::Class) && scope != 1,
+            kind: kind,
+            # Instance variables read as state on a class; test classes carry
+            # fixture state that would misrepresent them next to core classes.
+            count_instance_variables: kind == DeclarationCollector::CLASS && namespace.scope != LocationIndex::TEST,
           )
           [
-            declaration.is_a?(Rubydex::Class) ? 0 : 1,
-            scope,
+            kind,
+            namespace.scope,
             [declaration.ancestors.count - 1, 0].max,
             sites,
             [sites - 1, 0].max,
             descendants,
-            inbound_references.fetch(index, 0),
-            member_count,
+            inbound_counts.fetch(index, 0),
+            members,
             *ruby_counts,
-            instance_variable_count,
+            instance_variables,
           ]
         end
-        rows.concat(workspace.fetch(:rspec_groups).map { build_rspec_row })
+        rows.concat(Array.new(rspec_group_count) { RSPEC_ROW.dup })
       end
 
-      def build_rspec_row
-        [0, 1, *Array.new(11, 0)]
+      # One sweep over a namespace's direct and singleton members yields the
+      # workspace member count, the method and constant construct counts, and
+      # the instance-variable count together, since each of the three otherwise
+      # re-reads every member's definitions.
+      #
+      #: (Rubydex::Namespace, kind: Integer, count_instance_variables: bool) -> [Integer, Array[Integer], Integer]
+      def member_statistics(declaration, kind:, count_instance_variables:)
+        members = 0
+        instance_variables = 0
+        ruby_counts = Array.new(4, 0)
+        ruby_counts[kind] += 1
+
+        seen = Set.new
+        groups = [[declaration.members, true]]
+        singleton = declaration.singleton_class
+        groups << [singleton.members, false] if singleton
+        groups.each do |group, direct|
+          group.each do |member|
+            next unless seen.add?(member.name)
+            next unless member.definitions.any? { |definition| @locations.workspace?(definition.location) }
+
+            members += 1
+            construct = case member
+            when Rubydex::Method then DeclarationCollector::METHOD
+            when Rubydex::Constant, Rubydex::ConstantAlias then DeclarationCollector::CONSTANT
+            end
+            ruby_counts[construct] += 1 if construct
+            instance_variables += 1 if direct && count_instance_variables && member.is_a?(Rubydex::InstanceVariable)
+          end
+        end
+        [members, ruby_counts, instance_variables]
+      rescue StandardError
+        [members, ruby_counts, instance_variables]
       end
 
-      def build_package_rows(aggregates)
+      #: (Array[DeclarationCollector::dependency_package]) -> Array[Hash[String, untyped]]
+      def package_rows(aggregates)
         @manifest.packages.each_with_index.map do |package, index|
           aggregate = aggregates.fetch(index)
           {
@@ -240,7 +174,8 @@ module RubyLens
         end
       end
 
-      def build_dependency_system_rows
+      #: () -> Array[Hash[String, untyped]]
+      def dependency_system_rows
         return [] unless @manifest.respond_to?(:dependency_systems)
 
         @manifest.dependency_systems.map do |system|
@@ -252,282 +187,7 @@ module RubyLens
         end
       end
 
-      def collect_dependency_declaration(
-        aggregation,
-        positions,
-        declaration,
-        name,
-        is_namespace,
-        construct_index,
-        package_site_keys,
-        reference_count
-      )
-        return unless package_site_keys
-
-        package_index = nil
-        site_keys = nil
-        package_site_keys.each do |index, keys|
-          if site_keys.nil? || keys.length > site_keys.length ||
-              (keys.length == site_keys.length && index < package_index)
-            package_index = index
-            site_keys = keys
-          end
-        end
-
-        sites = site_keys.length > 1 ? site_keys.uniq.length : site_keys.length
-        row = [
-          namespace_kind(declaration),
-          is_namespace ? [declaration.ancestors.count - 1, 0].max : 0,
-          sites,
-          [sites - 1, 0].max,
-          is_namespace ? [declaration.descendants.count - 1, 0].max : 0,
-          reference_count,
-          is_namespace ? safe_length(declaration, :members) : 0,
-        ].freeze
-        local_index = aggregation.add(
-          package_index:,
-          row:,
-          construct_index:,
-        )
-        if reference_count.positive? && constant_reference_target?(declaration, is_namespace)
-          positions[name] = [package_index, local_index]
-        end
-      end
-
-      def workspace_reference_summary(graph, workspace, dependency_ordinal_by_name = {})
-        ordinal_by_name = workspace.fetch(:ordinal_by_name)
-        namespace_count = workspace.fetch(:namespace_names, ordinal_by_name).length
-        workspace_ranges = workspace.fetch(:definition_ranges, {})
-        inbound_counts = Hash.new(0)
-        workspace.fetch(:records).each_with_index do |record, index|
-          record.fetch(0).references.each do |reference|
-            location = begin
-              reference.location
-            rescue StandardError
-              next
-            end
-            inbound_counts[index] += 1 if workspace_location?(location)
-          end
-        end
-        links = []
-        retained_links = Set.new
-        attribution_count = 0
-
-        graph.constant_references.each do |reference|
-          break if links.length >= CONSTANT_REFERENCE_LINK_LIMIT ||
-            attribution_count >= CONSTANT_REFERENCE_ATTRIBUTION_LIMIT
-          next unless reference.is_a?(Rubydex::ResolvedConstantReference)
-
-          referenced_name = resolved_constant_reference_name(reference)
-          next unless referenced_name
-          referenced_ordinal = ordinal_by_name[referenced_name]
-          dependency_ordinal = dependency_ordinal_by_name[referenced_name] unless referenced_ordinal
-          next unless referenced_ordinal || dependency_ordinal
-
-          location = begin
-            reference.location
-          rescue StandardError
-            next
-          end
-          next unless workspace_location?(location)
-
-          attribution_count += 1
-
-          referenced_endpoint = referenced_ordinal || namespace_count + dependency_ordinal
-
-          location_values = begin
-            location.comparable_values
-          rescue StandardError
-            next
-          end
-          referring_ordinal = enclosing_definition_ordinal(location_values, workspace_ranges)
-          next unless referring_ordinal
-          next if referenced_endpoint == referring_ordinal
-
-          link = [referring_ordinal, referenced_endpoint]
-          next unless retained_links.add?(link)
-
-          links << link
-        end
-
-        ReferenceSummary.new(inbound_counts.freeze, links.freeze)
-      end
-
-      def resolved_constant_reference_name(reference)
-        reference.declaration.name
-      rescue StandardError
-        nil
-      end
-
-      def enclosing_definition_ordinal(location_values, ranges_by_uri)
-        uri, start_line, start_column, end_line, end_column = location_values
-        best = nil
-        ambiguous = false
-        ranges_by_uri.fetch(uri, []).each do |range|
-          range_start_line, range_start_column, range_end_line, range_end_column, ordinal = range
-          next if position_compare(range_start_line, range_start_column, start_line, start_column).positive?
-          next if position_compare(range_end_line, range_end_column, end_line, end_column).negative?
-
-          start_comparison = best ? position_compare(range_start_line, range_start_column, best[0], best[1]) : 1
-          end_comparison = best && start_comparison.zero? ? position_compare(range_end_line, range_end_column, best[2], best[3]) : 0
-          if start_comparison.positive? || (start_comparison.zero? && end_comparison.negative?)
-            best = range
-            ambiguous = false
-          elsif start_comparison.zero? && end_comparison.zero? && ordinal != best[4]
-            ambiguous = true
-          end
-        end
-
-        ambiguous ? nil : best&.fetch(4)
-      end
-
-      def position_compare(left_line, left_column, right_line, right_column)
-        line_comparison = left_line <=> right_line
-        line_comparison.zero? ? left_column <=> right_column : line_comparison
-      end
-
-      def package_index_for_location(location)
-        uri = location.uri
-        @package_index_by_uri.fetch(uri) do
-          path = source_path(uri)
-          @package_index_by_uri[uri] =
-            if path && @indexed_package_document_paths.include?(path)
-              @manifest.package_index_for(path)
-            end
-        end
-      end
-
-      # One sweep over the indexed documents resolves each URI once, yielding
-      # both the package-audit set and the [document, path] pairs the RSpec
-      # extractor reuses without re-enumerating documents or re-parsing URIs.
-      def resolve_documents(graph)
-        audited = @manifest.packages.flat_map(&:files).to_set
-        package_paths = Set.new
-        documents_with_paths = []
-        graph.documents.each do |document|
-          path = source_path(document.uri)
-          next unless path
-
-          documents_with_paths << [document, path]
-          package_paths << path if audited.include?(path)
-        end
-        [package_paths, documents_with_paths]
-      end
-
-      # One sweep over a namespace's direct and singleton members yields the
-      # workspace member count, the method/constant construct counts, and the
-      # instance-variable count that previously took three walks each re-reading
-      # every member's definitions. Membership comes from each member's own
-      # definition locations; the per-URI caches keep that scan cheap.
-      def member_statistics(declaration, count_instance_variables:)
-        member_count = 0
-        instance_variable_count = 0
-        ruby_counts = Array.new(4, 0)
-        own_construct = ruby_construct_index(declaration)
-        ruby_counts[own_construct] += 1 if own_construct == 0 || own_construct == 1
-
-        seen_names = Set.new
-        member_groups = [[declaration.members, true]]
-        singleton = declaration.singleton_class
-        member_groups << [singleton.members, false] if singleton
-        member_groups.each do |members, direct|
-          members.each do |member|
-            next unless seen_names.add?(member.name)
-            next unless member.definitions.any? { |definition| workspace_location?(definition.location) }
-
-            member_count += 1
-            construct_index = ruby_construct_index(member)
-            ruby_counts[construct_index] += 1 if construct_index && construct_index >= 2
-            if direct && count_instance_variables && member.is_a?(Rubydex::InstanceVariable)
-              instance_variable_count += 1
-            end
-          end
-        end
-        [member_count, ruby_counts, instance_variable_count]
-      rescue StandardError
-        [member_count, ruby_counts, instance_variable_count]
-      end
-
-      def workspace_location?(location)
-        uri = location.uri
-        @workspace_location_cache.fetch(uri) do
-          path = source_path(uri)
-          @workspace_location_cache[uri] = path ? @manifest.workspace_path?(path) : false
-        end
-      rescue StandardError
-        false
-      end
-
-      # 1 for a test-tree file, 0 for any other workspace file, nil when the
-      # URI has no workspace-relative path to classify.
-      def definition_scope(uri)
-        @definition_scope_by_uri.fetch(uri) do
-          relative = @manifest.relative_workspace_path(source_path(uri))
-          @definition_scope_by_uri[uri] =
-            if relative
-              relative.split(File::SEPARATOR).any? { |segment| TEST_SEGMENTS.include?(segment) } ? 1 : 0
-            end
-        end
-      end
-
-      def constant_reference_target?(declaration, is_namespace)
-        is_namespace ||
-          declaration.is_a?(Rubydex::Constant) ||
-          declaration.is_a?(Rubydex::ConstantAlias)
-      end
-
-      def model_eligible_declaration?(declaration, name = declaration.name)
-        return false if name.nil? || name.empty? || name.include?("<anonymous>")
-        return false if declaration.is_a?(Rubydex::Todo)
-        return true unless declaration.is_a?(Rubydex::SingletonClass)
-
-        attached = declaration.attached_class
-        !attached.is_a?(Rubydex::SingletonClass) && !attached.is_a?(Rubydex::Todo)
-      end
-
-      def canonical_namespace_definition?(declaration, definition)
-        (declaration.is_a?(Rubydex::Class) && definition.is_a?(Rubydex::ClassDefinition)) ||
-          (declaration.is_a?(Rubydex::Module) && definition.is_a?(Rubydex::ModuleDefinition))
-      end
-
-      def namespace_kind(declaration)
-        case declaration
-        when Rubydex::Class then 0
-        when Rubydex::Module then 1
-        else 2
-        end
-      end
-
-      def ruby_construct_index(declaration)
-        case declaration
-        when Rubydex::SingletonClass then nil
-        when Rubydex::Class then 0
-        when Rubydex::Module then 1
-        when Rubydex::Method then 2
-        when Rubydex::Constant, Rubydex::ConstantAlias then 3
-        end
-      end
-
-      def source_path(uri_string)
-        @source_path_cache.fetch(uri_string) do
-          @source_path_cache[uri_string] = SourcePath.from_file_uri(uri_string)
-        end
-      end
-
-      def safe_length(object, method)
-        records = object.public_send(method)
-        size = records.size
-        size.nil? ? safe_count(records) : size
-      rescue StandardError
-        safe_count(records)
-      end
-
-      def safe_count(records)
-        records ? records.count : 0
-      rescue StandardError
-        0
-      end
-
+      #: () -> String
       def project_name
         basename = @manifest.root.basename.to_s
         return "IRB" if basename.casecmp("irb").zero?

data/lib/rubylens/model/dependency_aggregation.rb

@@ -17,10 +17,12 @@ module RubyLens
         local_index = @rows[package_index].length
         @ruby_counts[package_index][construct_index] += 1 if construct_index
         maxima = @signal_maxima
-        SIGNAL_COLUMNS.each do |column|
+        column = SIGNAL_COLUMNS.begin
+        while column <= SIGNAL_COLUMNS.end
           value = row[column]
           index = column - 1
           maxima[index] = value if value > maxima[index]
+          column += 1
         end
         @rows[package_index] << (row.frozen? ? row : row.dup.freeze)
         local_index

data/lib/rubylens/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyLens
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubylens
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - RubyLens contributors
@@ -69,6 +69,10 @@ files:
 - lib/rubylens/errors.rb
 - lib/rubylens/generator.rb
 - lib/rubylens/git_repository.rb
+- lib/rubylens/index/constant_reference_collector.rb
+- lib/rubylens/index/declaration_collector.rb
+- lib/rubylens/index/git_package_source.rb
+- lib/rubylens/index/location_index.rb
 - lib/rubylens/index/manifest.rb
 - lib/rubylens/index/rspec_extractor.rb
 - lib/rubylens/index/rubydex_adapter.rb
@@ -82,12 +86,12 @@ files:
 - lib/rubylens/showcase_model.rb
 - lib/rubylens/showcase_writer.rb
 - lib/rubylens/version.rb
-homepage: https://st0012.dev/rails-galaxy/
+homepage: https://st0012.dev/ruby-galaxies/
 licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-  homepage_uri: https://st0012.dev/rails-galaxy/
+  homepage_uri: https://st0012.dev/ruby-galaxies/
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths: