rucoa 0.8.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 26c4a8d526acb34d3722fc4b78e4c8fa0a1bac7bfc11d72af4b5962afdbc01c9
-  data.tar.gz: b49e5bdca272898e10870fbad7f99b2ba5cf63e0d1acef074d3af1928b69058b
+  metadata.gz: 3344309136313473ea6d4fecd4c57745fb4bc8fc1404c40f7126c0a5d5eef440
+  data.tar.gz: 1bfb57eee21c860f54b8c82452717d987a31bc977a5a7853b6e08b0d486fd5ac
 SHA512:
-  metadata.gz: 4de0736efd9d7b44d7756bfe5aedf6fc60d0b3a9ce9ab55cb0e3c6b83ca0525017e0ddb629d612ec4c05a8cae97f1d902bf33a3090c00570765c344821393bf6
-  data.tar.gz: 8228a81e3b4408274d2e51f2c339e724e4c4615f4af2a311bad68c48b74d32a09773cf5a0caaa780135780d7510b95aa64579ec6d009bf7fe711cb590660bde8
+  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.8.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

@@ -2,48 +2,179 @@
 
 module Rucoa
   class DefinitionStore
-    # @return [Array<Rucoa::Definition::Base>]
-    attr_accessor :definitions
-
     def initialize
-      @definitions = []
+      @definition_by_qualified_name = {}
+      @qualified_names_by_uri = ::Hash.new { |hash, key| hash[key] = [] }
     end
 
-    # @param source_path [String]
-    # @return [Array<Rucoa::Definition::Base>]
-    def update_definitions_defined_in(source_path, definitions:)
-      delete_definitions_defined_in(source_path)
-      @definitions += definitions
+    # @return [String]
+    def inspect
+      "#<#{self.class} definitions_count=#{@definition_by_qualified_name.count}>"
     end
 
-    # @param full_qualified_name [String]
-    # @return [Array<Rucoa::Definitions::Base>]
-    def select_by_full_qualified_name(full_qualified_name)
-      @definitions.select do |definition|
-        definition.full_qualified_name == full_qualified_name
+    # @param definitions [Array<Rucoa::Definition::Base>]
+    # @return [void]
+    def bulk_add(definitions)
+      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 from definitions
+    #   definition_store = Rucoa::DefinitionStore.new
+    #   foo = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       module A
+    #         class 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 < 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.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_in(source)
+      add_definitions_in(source)
+      resolve_constants_in(source)
+    end
+
+    # @param qualified_name [String]
+    # @return [Rucoa::Definitions::Base, nil]
+    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.definitions += 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.full_qualified_name).to eq('IO.write')
-    def find_method_definition_by(method_name:, namespace:, singleton: false)
-      if singleton
-        singleton_method_definitions_of(namespace)
-      else
-        instance_method_definitions_of(namespace)
-      end.find do |method_definition|
-        method_definition.method_name == method_name
+    #   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
+
+      ancestors_of(definition).find do |ancestor|
+        method_marker = singleton ? '.' : '#'
+        qualified_method_name = [
+          ancestor.qualified_name,
+          method_marker,
+          method_name
+        ].join
+        method_definition = find_definition_by_qualified_name(qualified_method_name)
+        break method_definition if method_definition
       end
     end
 
@@ -51,28 +182,25 @@ module Rucoa
     # @return [Array<Rucoa::Definitions::MethodDefinition>]
     # @example includes ancestors' methods
     #   definition_store = Rucoa::DefinitionStore.new
-    #   definition_store.definitions += Rucoa::DefinitionArchiver.load
+    #   definition_store.bulk_add(Rucoa::DefinitionArchiver.load)
     #   subject = definition_store.instance_method_definitions_of('File')
-    #   expect(subject.map(&:full_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.definitions += Rucoa::DefinitionArchiver.load
+    #   definition_store.bulk_add(Rucoa::DefinitionArchiver.load)
     #   subject = definition_store.instance_method_definitions_of('singleton<File>')
-    #   expect(subject.map(&:full_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_class_or_module_definition(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(&:full_qualified_name).flat_map do |full_qualified_type_name|
-        definitions.select do |definition|
-          definition.namespace == full_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
@@ -81,29 +209,21 @@ module Rucoa
     # @return [Array<Rucoa::Definitions::MethodDefinition>]
     # @example returns singleton method definitions of File
     #   definition_store = Rucoa::DefinitionStore.new
-    #   definition_store.definitions += Rucoa::DefinitionArchiver.load
+    #   definition_store.bulk_add(Rucoa::DefinitionArchiver.load)
     #   subject = definition_store.singleton_method_definitions_of('File')
-    #   expect(subject.map(&:full_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_class_or_module_definition(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(&:full_qualified_name).flat_map do |full_qualified_type_name|
-        definitions.select do |definition|
-          definition.namespace == full_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
 
-    # @return [Array<Rucoa::Definition::ConstantDefinition>]
-    def constant_definitions
-      @definitions.grep(Definitions::ConstantDefinition)
-    end
-
     # @param namespace [String]
     # @return [Array<Rucoa::Definitions::ConstantDefinition>] e.g. File::Separator, File::SEPARATOR, etc.
     def constant_definitions_under(namespace)
@@ -112,41 +232,83 @@ 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_in(source)
+      @qualified_names_by_uri[source.uri].each do |qualified_name|
+        @definition_by_qualified_name.delete(qualified_name)
+      end
+      @qualified_names_by_uri.delete(source.uri)
+    end
+
     # @param type [String]
     # @return [String, nil]
     def singleton_class_name_from(type)
       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_name = class_definition.super_class_name)
-        class_definition = find_class_or_module_definition(super_class_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
 
-    # @param type [String]
-    # @return [Rucoa::Definitions::Class, Rucoa::Definitions::Module, nil]
-    def find_class_or_module_definition(type)
-      @definitions.find do |definition|
-        definition.full_qualified_name == type
-      end
+    # @return [Array<Rucoa::Definitions::Base>]
+    def definitions
+      @definition_by_qualified_name.values
     end
 
     # @return [Array<Rucoa::Definition::MethodDefinition>]
     def method_definitions
-      @definitions.grep(Definitions::MethodDefinition)
+      definitions.grep(Definitions::MethodDefinition)
     end
 
     # @return [Array<Rucoa::Definition::MethodDefinition>]
@@ -159,11 +321,42 @@ module Rucoa
       method_definitions.select(&:singleton_method?)
     end
 
-    # @param source_path [String]
-    # @return [Array<Rucoa::Definition::Base>]
-    def delete_definitions_defined_in(source_path)
-      @definitions.delete_if do |definition|
-        definition.source_path == source_path
+    # @return [Array<Rucoa::Definition::ConstantDefinition>]
+    def constant_definitions
+      definitions.grep(Definitions::ConstantDefinition)
+    end
+
+    # @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
+
+    # @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

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

@@ -4,12 +4,28 @@ module Rucoa
   module Definitions
     class ClassDefinition < ModuleDefinition
       # @return [String, nil]
-      attr_reader :super_class_name
+      attr_accessor :super_class_qualified_name
 
-      # @param super_class_name [String, nil]
-      def initialize(super_class_name:, **keyword_arguments)
+      # @return [Rucoa::UnqualifiedName, nil]
+      attr_accessor :super_class_unqualified_name
+
+      # @param super_class_qualified_name [String, nil]
+      # @param super_class_unqualified_name [Rucoa::UnqualifiedName, nil]
+      def initialize(
+        super_class_qualified_name: nil,
+        super_class_unqualified_name: nil,
+        **keyword_arguments
+      )
         super(**keyword_arguments)
-        @super_class_name = super_class_name
+        @super_class_qualified_name = super_class_qualified_name
+        @super_class_unqualified_name = super_class_unqualified_name
+      end
+
+      # @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

data/lib/rucoa/definitions/constant_definition.rb

@@ -5,25 +5,30 @@ module Rucoa
     # Represents class definition, module definition, or constant assignment.
     class ConstantDefinition < Base
       # @return [String]
-      attr_reader :full_qualified_name
+      attr_reader :qualified_name
 
-      # @return [String]
-      attr_reader :source_path
-
-      # @param full_qualified_name [String]
-      # @param source_path [String]
-      def initialize(full_qualified_name:, source_path:)
-        super()
-        @full_qualified_name = full_qualified_name
-        @source_path = source_path
+      # @param qualified_name [String]
+      def initialize(
+        qualified_name:,
+        **keyword_arguments
+      )
+        super(**keyword_arguments)
+        @qualified_name = qualified_name
       end
 
       # @return [String]
       # @example returns non-full-qualified name
-      #   definition = Rucoa::Definitions::ConstantDefinition.new(
-      #     full_qualified_name: 'Foo::Bar::Baz',
-      #     source_path: '/path/to/foo/bar/baz.rb'
-      #   )
+      #   definition = Rucoa::Source.new(
+      #     content: <<~RUBY,
+      #       module Foo
+      #         module Bar
+      #           class Baz
+      #           end
+      #         end
+      #       end
+      #     RUBY
+      #     uri: 'file:///path/to/foo/bar/baz.rb',
+      #   ).definitions[2]
       #   expect(definition.name).to eq('Baz')
       def name
         names.last
@@ -31,10 +36,17 @@ module Rucoa
 
       # @return [String]
       # @example returns namespace
-      #   definition = Rucoa::Definitions::ConstantDefinition.new(
-      #     full_qualified_name: 'Foo::Bar::Baz',
-      #     source_path: '/path/to/foo/bar/baz.rb'
-      #   )
+      #   definition = Rucoa::Source.new(
+      #     content: <<~RUBY,
+      #       module Foo
+      #         module Bar
+      #           class Baz
+      #           end
+      #         end
+      #       end
+      #     RUBY
+      #     uri: 'file:///path/to/foo/bar/baz.rb',
+      #   ).definitions[2]
       #   expect(definition.namespace).to eq('Foo::Bar')
       def namespace
         names[..-2].join('::')
@@ -44,7 +56,7 @@ module Rucoa
 
       # @return [Array<String>]
       def names
-        @names ||= full_qualified_name.split('::')
+        @names ||= qualified_name.split('::')
       end
     end
   end