rucoa 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 237fa68185426d66437c43fc2a3f34f7f85ee7309eb4ed6bb6ce4e31b5dfbb6e
-  data.tar.gz: e9f96daf65c7ccef564b2e06756497fd4d98bd946911487ca2fdd32740436e4b
+  metadata.gz: 3344309136313473ea6d4fecd4c57745fb4bc8fc1404c40f7126c0a5d5eef440
+  data.tar.gz: 1bfb57eee21c860f54b8c82452717d987a31bc977a5a7853b6e08b0d486fd5ac
 SHA512:
-  metadata.gz: 3698e9db246d46ce64314df9b4a7418278a6e9f65cc2e80dfece624b547c5ab238af42b456370d1096e872f6e30aefdb132b5b2bd435ec03d1e6cccdac0a908a
-  data.tar.gz: 5088d4dcc1fa5ad6e053a155246da87602071fa8283b4f42e1b4e9040b222be5f82622343ad2467b5cdf8003b02293e70ea8d391dc99f478ee36a1389311a9d4
+  metadata.gz: 4e9efaf6fd608590febfdc450ba487306d35832196f026a77e6ce8b314b78f477a1a79179637153a3977be407ab0f7079ff8bdb23611a0ea2e0f89681bb9637d
+  data.tar.gz: cef07b36f534e390a977f694bf5ce97010b14fce34b990b19742682112a741b17914750e1c8de2e881da03620e8d01bce5d0014bc284b1afc725a0de91a8b88b

data/.rubocop.yml

@@ -32,9 +32,15 @@ RSpec/NamedSubject:
 Security/MarshalLoad:
   Enabled: false
 
+Sevencop/AutoloadOrdered:
+  Enabled: true
+
 Sevencop/HashLiteralOrder:
   Enabled: true
 
+Sevencop/MethodDefinitionMultilineArguments:
+  Enabled: true
+
 Style/Documentation:
   Enabled: false
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rucoa (0.9.0)
+    rucoa (0.10.0)
       parser
       rbs
       rubocop
@@ -27,13 +27,13 @@ GEM
       rspec-mocks (~> 3.11.0)
     rspec-core (3.11.0)
       rspec-support (~> 3.11.0)
-    rspec-expectations (3.11.0)
+    rspec-expectations (3.11.1)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.11.0)
     rspec-mocks (3.11.1)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.11.0)
-    rspec-support (3.11.0)
+    rspec-support (3.11.1)
     rubocop (1.36.0)
       json (~> 2.3)
       parallel (~> 1.10)
@@ -46,17 +46,17 @@ GEM
       unicode-display_width (>= 1.4.0, < 3.0)
     rubocop-ast (1.21.0)
       parser (>= 3.1.1.0)
-    rubocop-performance (1.14.3)
+    rubocop-performance (1.15.0)
       rubocop (>= 1.7.0, < 2.0)
       rubocop-ast (>= 0.4.0)
     rubocop-rake (0.6.0)
       rubocop (~> 1.0)
-    rubocop-rspec (2.12.1)
-      rubocop (~> 1.31)
+    rubocop-rspec (2.13.2)
+      rubocop (~> 1.33)
     ruby-progressbar (1.11.0)
-    sevencop (0.10.0)
+    sevencop (0.12.1)
       rubocop
-    unicode-display_width (2.2.0)
+    unicode-display_width (2.3.0)
     webrick (1.7.0)
     yard (0.9.28)
       webrick (~> 1.7.0)

data/lib/rucoa/configuration.rb

@@ -148,7 +148,10 @@ module Rucoa
     # @param keys [Array<String>]
     # @param default [Object]
     # @return [Object]
-    def fetch(*keys, default:)
+    def fetch(
+      *keys,
+      default:
+    )
       value = @settings.dig(*keys)
       if value.nil?
         default

data/lib/rucoa/definition_store.rb

@@ -3,22 +3,29 @@
 module Rucoa
   class DefinitionStore
     def initialize
-      @definition_by_full_qualified_name = {}
-      @fully_qualified_names_by_uri = ::Hash.new { |hash, key| hash[key] = [] }
+      @definition_by_qualified_name = {}
+      @qualified_names_by_uri = ::Hash.new { |hash, key| hash[key] = [] }
+    end
+
+    # @return [String]
+    def inspect
+      "#<#{self.class} definitions_count=#{@definition_by_qualified_name.count}>"
     end
 
     # @param definitions [Array<Rucoa::Definition::Base>]
     # @return [void]
     def bulk_add(definitions)
-      definitions.each do |definition|
-        @fully_qualified_names_by_uri["file://#{definition.source_path}"] << definition.fully_qualified_name
-        @definition_by_full_qualified_name[definition.fully_qualified_name] = definition
+      definitions.group_by(&:qualified_name).each_value.map do |grouped_definitions|
+        grouped_definitions.reduce(:merge!)
+      end.each do |definition|
+        @qualified_names_by_uri[definition.location.uri] << definition.qualified_name if definition.location
+        @definition_by_qualified_name[definition.qualified_name] = definition
       end
     end
 
     # @param source [Rucoa::Source]
     # @return [void]
-    # @example resolves super class name correctly by using existent definitions
+    # @example resolves super class name from definitions
     #   definition_store = Rucoa::DefinitionStore.new
     #   foo = Rucoa::Source.new(
     #     content: <<~RUBY,
@@ -40,62 +47,134 @@ module Rucoa
     #     uri: 'file:///path/to/a/bar.rb',
     #   )
     #   definition_store.update_from(bar)
-    #   definition = definition_store.find_definition_by_fully_qualified_name('A::Bar')
-    #   expect(definition.super_class_fully_qualified_name).to eq('A::Foo')
+    #   definition = definition_store.find_definition_by_qualified_name('A::Bar')
+    #   expect(definition.super_class_qualified_name).to eq('A::Foo')
+    # @example resolves included module names from definitions
+    #   definition_store = Rucoa::DefinitionStore.new
+    #   foo = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       module A
+    #         module Foo
+    #         end
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/a/foo.rb',
+    #   )
+    #   definition_store.update_from(foo)
+    #   bar = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       module A
+    #         class Bar
+    #           include Foo
+    #         end
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/a/bar.rb',
+    #   )
+    #   definition_store.update_from(bar)
+    #   definition = definition_store.find_definition_by_qualified_name('A::Bar')
+    #   expect(definition.included_module_qualified_names).to eq(%w[A::Foo])
     def update_from(source)
-      delete_definitions_about(source)
-
-      # Need to store definitions before super class resolution.
-      source.definitions.group_by(&:source_path).each do |source_path, definitions|
-        @fully_qualified_names_by_uri["file://#{source_path}"] += definitions.map(&:fully_qualified_name)
-        definitions.each do |definition|
-          @definition_by_full_qualified_name[definition.fully_qualified_name] = definition
-        end
-      end
-
-      source.definitions.each do |definition|
-        next unless definition.is_a?(Definitions::ClassDefinition)
-        next if definition.super_class_resolved?
-
-        definition.super_class_fully_qualified_name = resolve_super_class_of(definition)
-      end
+      delete_definitions_in(source)
+      add_definitions_in(source)
+      resolve_constants_in(source)
     end
 
-    # @param fully_qualified_name [String]
+    # @param qualified_name [String]
     # @return [Rucoa::Definitions::Base, nil]
-    def find_definition_by_fully_qualified_name(fully_qualified_name)
-      @definition_by_full_qualified_name[fully_qualified_name]
+    def find_definition_by_qualified_name(qualified_name)
+      @definition_by_qualified_name[qualified_name]
     end
 
     # @param method_name [String]
     # @param namespace [String]
     # @param singleton [Boolean]
     # @return [Rucoa::Definition::MethodDefinition, nil]
-    # @example has the ability to find `IO.write` from `File.write`
+    # @example Supports inheritance
+    #   source = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       class A
+    #         def foo
+    #         end
+    #       end
+    #
+    #       class B < A
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/example.rb'
+    #   )
     #   definition_store = Rucoa::DefinitionStore.new
-    #   definition_store.bulk_add(Rucoa::DefinitionArchiver.load)
+    #   definition_store.update_from(source)
     #   subject = definition_store.find_method_definition_by(
-    #     method_name: 'write',
-    #     namespace: 'File',
-    #     singleton: true
+    #     method_name: 'foo',
+    #     namespace: 'B',
+    #     singleton: false
     #   )
-    #   expect(subject.fully_qualified_name).to eq('IO.write')
-    def find_method_definition_by(method_name:, namespace:, singleton: false)
-      definition = find_definition_by_fully_qualified_name(namespace)
+    #   expect(subject.qualified_name).to eq('A#foo')
+    # @example supports `include`
+    #   source = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       module A
+    #         def foo
+    #         end
+    #       end
+    #
+    #       class B
+    #         include A
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/example.rb'
+    #   )
+    #   definition_store = Rucoa::DefinitionStore.new
+    #   definition_store.update_from(source)
+    #   subject = definition_store.find_method_definition_by(
+    #     method_name: 'foo',
+    #     namespace: 'B',
+    #     singleton: false
+    #   )
+    #   expect(subject.qualified_name).to eq('A#foo')
+    # @example supports `prepend`
+    #   source = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       module A
+    #         def foo
+    #         end
+    #       end
+    #
+    #       class B
+    #         prepend A
+    #
+    #         def foo
+    #         end
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/example.rb'
+    #   )
+    #   definition_store = Rucoa::DefinitionStore.new
+    #   definition_store.update_from(source)
+    #   subject = definition_store.find_method_definition_by(
+    #     method_name: 'foo',
+    #     namespace: 'B',
+    #     singleton: false
+    #   )
+    #   expect(subject.qualified_name).to eq('A#foo')
+    def find_method_definition_by(
+      method_name:,
+      namespace:,
+      singleton: false
+    )
+      definition = find_definition_by_qualified_name(namespace)
       return unless definition
 
-      [
-        namespace,
-        *ancestor_definitions_of(definition).map(&:fully_qualified_name)
-      ].find do |fully_qualified_name|
+      ancestors_of(definition).find do |ancestor|
         method_marker = singleton ? '.' : '#'
-        fully_qualified_method_name = [
-          fully_qualified_name,
+        qualified_method_name = [
+          ancestor.qualified_name,
           method_marker,
           method_name
         ].join
-        definition = find_definition_by_fully_qualified_name(fully_qualified_method_name)
-        break definition if definition
+        method_definition = find_definition_by_qualified_name(qualified_method_name)
+        break method_definition if method_definition
       end
     end
 
@@ -105,26 +184,23 @@ module Rucoa
     #   definition_store = Rucoa::DefinitionStore.new
     #   definition_store.bulk_add(Rucoa::DefinitionArchiver.load)
     #   subject = definition_store.instance_method_definitions_of('File')
-    #   expect(subject.map(&:fully_qualified_name)).to include('IO#raw')
+    #   expect(subject.map(&:qualified_name)).to include('IO#raw')
     # @example responds to `singleton<File>`
     #   definition_store = Rucoa::DefinitionStore.new
     #   definition_store.bulk_add(Rucoa::DefinitionArchiver.load)
     #   subject = definition_store.instance_method_definitions_of('singleton<File>')
-    #   expect(subject.map(&:fully_qualified_name)).to include('IO.write')
+    #   expect(subject.map(&:qualified_name)).to include('IO.write')
     def instance_method_definitions_of(type)
       singleton_class_name = singleton_class_name_from(type)
       return singleton_method_definitions_of(singleton_class_name) if singleton_class_name
 
-      class_or_module_definition = find_definition_by_fully_qualified_name(type)
+      class_or_module_definition = find_definition_by_qualified_name(type)
       return [] unless class_or_module_definition
 
-      definitions = instance_method_definitions
-      [
-        class_or_module_definition,
-        *ancestor_definitions_of(class_or_module_definition)
-      ].map(&:fully_qualified_name).flat_map do |fully_qualified_type_name|
-        definitions.select do |definition|
-          definition.namespace == fully_qualified_type_name
+      method_definitions = instance_method_definitions
+      ancestors_of(class_or_module_definition).flat_map do |ancestor|
+        method_definitions.select do |method_definition|
+          method_definition.namespace == ancestor.qualified_name
         end
       end
     end
@@ -135,18 +211,15 @@ module Rucoa
     #   definition_store = Rucoa::DefinitionStore.new
     #   definition_store.bulk_add(Rucoa::DefinitionArchiver.load)
     #   subject = definition_store.singleton_method_definitions_of('File')
-    #   expect(subject.map(&:fully_qualified_name)).to include('IO.write')
+    #   expect(subject.map(&:qualified_name)).to include('IO.write')
     def singleton_method_definitions_of(type)
-      class_or_module_definition = find_definition_by_fully_qualified_name(type)
+      class_or_module_definition = find_definition_by_qualified_name(type)
       return [] unless class_or_module_definition
 
-      definitions = singleton_method_definitions
-      [
-        class_or_module_definition,
-        *ancestor_definitions_of(class_or_module_definition)
-      ].map(&:fully_qualified_name).flat_map do |fully_qualified_type_name|
-        definitions.select do |definition|
-          definition.namespace == fully_qualified_type_name
+      method_definitions = singleton_method_definitions
+      ancestors_of(class_or_module_definition).flat_map do |ancestor|
+        method_definitions.select do |method_definition|
+          method_definition.namespace == ancestor.qualified_name
         end
       end
     end
@@ -159,15 +232,27 @@ module Rucoa
       end
     end
 
+    # @param unqualified_name [Rucoa::UnqualifiedName]
+    # @return [String]
+    def resolve_constant(unqualified_name)
+      (
+        unqualified_name.module_nesting.map do |prefix|
+          "#{prefix}::#{unqualified_name.chained_name}"
+        end + [unqualified_name.chained_name]
+      ).find do |candidate|
+        find_definition_by_qualified_name(candidate)
+      end || unqualified_name.chained_name
+    end
+
     private
 
     # @param source [Rucoa::Source]
     # @return [void]
-    def delete_definitions_about(source)
-      @fully_qualified_names_by_uri[source.uri].each do |fully_qualified_name|
-        @definition_by_full_qualified_name.delete(fully_qualified_name)
+    def delete_definitions_in(source)
+      @qualified_names_by_uri[source.uri].each do |qualified_name|
+        @definition_by_qualified_name.delete(qualified_name)
       end
-      @fully_qualified_names_by_uri.delete(source.uri)
+      @qualified_names_by_uri.delete(source.uri)
     end
 
     # @param type [String]
@@ -176,25 +261,49 @@ module Rucoa
       type[/singleton<(\w+)>/, 1]
     end
 
-    # @param class_or_module_definition [Rucoa::Definitions::Class, Rucoa::Definitions::Module]
-    # @return [Array<Rucoa::Definitions::Class>]
-    def ancestor_definitions_of(class_or_module_definition)
-      return [] unless class_or_module_definition.is_a?(Definitions::ClassDefinition)
+    # @param definition [Rucoa::Definitions::Class, Rucoa::Definitions::Module]
+    # @return [Array<Rucoa::Definitions::Class>] The classes and modules that are traced in method search (as `Module#ancestors` in Ruby)
+    def ancestors_of(definition)
+      if definition.is_a?(Rucoa::Definitions::ClassDefinition)
+        [definition, *super_class_definitions_of(definition)]
+      else
+        [definition]
+      end.flat_map do |base|
+        module_ancestors_of(base)
+      end
+    end
+
+    # @param definition [Rucoa::Definitions::Class, Rucoa::Definitions::Module]
+    # @return [Array<Rucoa::Definitions::Class, Rucoa::Definitions::Module>] An array of prepended, itself, and included definitions
+    def module_ancestors_of(definition)
+      [
+        *definition.prepended_module_qualified_names.filter_map do |qualified_name|
+          find_definition_by_qualified_name(qualified_name)
+        end.reverse,
+        definition,
+        *definition.included_module_qualified_names.filter_map do |qualified_name|
+          find_definition_by_qualified_name(qualified_name)
+        end.reverse
+      ]
+    end
 
+    # @param definition [Rucoa::Definitions::Class]
+    # @return [Array<Rucoa::Definitions::Class>] super "class"es (not including modules) in closest-first order
+    def super_class_definitions_of(definition)
       result = []
-      class_definition = class_or_module_definition
-      while (super_class_fully_qualified_name = class_definition.super_class_fully_qualified_name)
-        class_definition = find_definition_by_fully_qualified_name(super_class_fully_qualified_name)
-        break unless class_definition
+      while (super_class_qualified_name = definition.super_class_qualified_name)
+        super_definition = find_definition_by_qualified_name(super_class_qualified_name)
+        break unless super_definition
 
-        result << class_definition
+        result << super_definition
+        definition = super_definition
       end
       result
     end
 
     # @return [Array<Rucoa::Definitions::Base>]
     def definitions
-      @definition_by_full_qualified_name.values
+      @definition_by_qualified_name.values
     end
 
     # @return [Array<Rucoa::Definition::MethodDefinition>]
@@ -217,14 +326,38 @@ module Rucoa
       definitions.grep(Definitions::ConstantDefinition)
     end
 
-    # @param class_definition [Rucoa::Definitions::ClassDefinition]
-    # @return [String]
-    def resolve_super_class_of(class_definition)
-      return 'Object' unless class_definition.super_class_chained_name
+    # @param source [Rucoa::Source]
+    # @return [void]
+    def add_definitions_in(source)
+      source.definitions.group_by do |definition|
+        definition.location.uri
+      end.each do |uri, definitions|
+        @qualified_names_by_uri[uri] += definitions.map(&:qualified_name)
+        definitions.each do |definition|
+          @definition_by_qualified_name[definition.qualified_name] = definition
+        end
+      end
+    end
 
-      class_definition.super_class_candidates.find do |candidate|
-        find_definition_by_fully_qualified_name(candidate)
-      end || class_definition.super_class_chained_name
+    # @param source [Rucoa::Source]
+    # @return [void]
+    def resolve_constants_in(source)
+      source.definitions.each do |definition|
+        next unless definition.is_a?(Definitions::ClassDefinition)
+
+        definition.super_class_qualified_name = resolve_constant(definition.super_class_unqualified_name)
+        definition.super_class_unqualified_name = nil
+
+        definition.included_module_qualified_names = definition.included_module_unqualified_names.map do |unqualified_name|
+          resolve_constant(unqualified_name)
+        end
+        definition.included_module_unqualified_names = []
+
+        definition.prepended_module_qualified_names = definition.prepended_module_unqualified_names.map do |unqualified_name|
+          resolve_constant(unqualified_name)
+        end
+        definition.prepended_module_unqualified_names = []
+      end
     end
   end
 end

data/lib/rucoa/definitions/base.rb

@@ -3,9 +3,20 @@
 module Rucoa
   module Definitions
     class Base
-      # @return [String]
-      def source_path
-        raise ::NotImplementedError
+      # @return [String, nil]
+      attr_reader :description
+
+      # @return [Rucoa::Location, nil]
+      attr_accessor :location
+
+      # @param description [String, nil]
+      # @param location [Rucoa::Location, nil]
+      def initialize(
+        description:,
+        location:
+      )
+        @description = description
+        @location = location
       end
     end
   end

data/lib/rucoa/definitions/class_definition.rb

@@ -3,79 +3,29 @@
 module Rucoa
   module Definitions
     class ClassDefinition < ModuleDefinition
-      # @return [Arra<String>, nil]
-      attr_reader :module_nesting
-
       # @return [String, nil]
-      attr_reader :super_class_chained_name
+      attr_accessor :super_class_qualified_name
 
-      # @return [String, nil]
-      attr_accessor :super_class_fully_qualified_name
+      # @return [Rucoa::UnqualifiedName, nil]
+      attr_accessor :super_class_unqualified_name
 
-      # @param module_nesting [Array<String>, nil]
-      # @param super_class_chained_name [String, nil]
-      # @param super_class_fully_qualified_name [String, nil]
+      # @param super_class_qualified_name [String, nil]
+      # @param super_class_unqualified_name [Rucoa::UnqualifiedName, nil]
       def initialize(
-        module_nesting: nil,
-        super_class_chained_name: nil,
-        super_class_fully_qualified_name: nil,
+        super_class_qualified_name: nil,
+        super_class_unqualified_name: nil,
         **keyword_arguments
       )
         super(**keyword_arguments)
-        @module_nesting = module_nesting
-        @super_class_chained_name = super_class_chained_name
-        @super_class_fully_qualified_name = super_class_fully_qualified_name
+        @super_class_qualified_name = super_class_qualified_name
+        @super_class_unqualified_name = super_class_unqualified_name
       end
 
-      # @return [Boolean]
-      # @example returns false on not-resolved case
-      #   definition = Rucoa::Definitions::ClassDefinition.new(
-      #     fully_qualified_name: 'Foo',
-      #     source_path: '/path/to/foo.rb',
-      #     super_class_chained_name: 'Bar'
-      #   )
-      #   expect(definition).not_to be_super_class_resolved
-      # @example returns true on resolved case
-      #   definition = Rucoa::Definitions::ClassDefinition.new(
-      #     fully_qualified_name: 'Foo',
-      #     source_path: '/path/to/foo.rb',
-      #     super_class_chained_name: 'Bar',
-      #     super_class_fully_qualified_name: 'Bar'
-      #   )
-      #   expect(definition).to be_super_class_resolved
-      def super_class_resolved?
-        !@super_class_fully_qualified_name.nil?
-      end
-
-      # @return [Array<String>]
-      # @example returns candidates of super class fully qualified name
-      #   class_definition = Rucoa::Definitions::ClassDefinition.new(
-      #     fully_qualified_name: nil,
-      #     module_nesting: %w[B::A B],
-      #     source_path: '/path/to/b/a/c.rb',
-      #     super_class_chained_name: 'C'
-      #   )
-      #   expect(class_definition.super_class_candidates).to eq(
-      #     %w[B::A::C B::C C]
-      #   )
-      # @example returns only correct answer if it's already resolved
-      #   class_definition = Rucoa::Definitions::ClassDefinition.new(
-      #     fully_qualified_name: 'B::A::C',
-      #     source_path: '/path/to/b/a/c.rb',
-      #     super_class_fully_qualified_name: 'B::A::C'
-      #   )
-      #   expect(class_definition.super_class_candidates).to eq(
-      #     %w[B::A::C]
-      #   )
-      def super_class_candidates
-        return [super_class_fully_qualified_name] if super_class_resolved?
-
-        module_nesting.map do |chained_name|
-          [
-            chained_name,
-            super_class_chained_name
-          ].join('::')
-        end + [super_class_chained_name]
+      # @param other [Rucoa::Definitions::ClassDefinition]
+      def merge!(other)
+        self.super_class_qualified_name ||= other.super_class_qualified_name
+        self.super_class_unqualified_name ||= other.super_class_unqualified_name
+        super
       end
     end
   end