rucoa 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 26c4a8d526acb34d3722fc4b78e4c8fa0a1bac7bfc11d72af4b5962afdbc01c9
-  data.tar.gz: b49e5bdca272898e10870fbad7f99b2ba5cf63e0d1acef074d3af1928b69058b
+  metadata.gz: 237fa68185426d66437c43fc2a3f34f7f85ee7309eb4ed6bb6ce4e31b5dfbb6e
+  data.tar.gz: e9f96daf65c7ccef564b2e06756497fd4d98bd946911487ca2fdd32740436e4b
 SHA512:
-  metadata.gz: 4de0736efd9d7b44d7756bfe5aedf6fc60d0b3a9ce9ab55cb0e3c6b83ca0525017e0ddb629d612ec4c05a8cae97f1d902bf33a3090c00570765c344821393bf6
-  data.tar.gz: 8228a81e3b4408274d2e51f2c339e724e4c4615f4af2a311bad68c48b74d32a09773cf5a0caaa780135780d7510b95aa64579ec6d009bf7fe711cb590660bde8
+  metadata.gz: 3698e9db246d46ce64314df9b4a7418278a6e9f65cc2e80dfece624b547c5ab238af42b456370d1096e872f6e30aefdb132b5b2bd435ec03d1e6cccdac0a908a
+  data.tar.gz: 5088d4dcc1fa5ad6e053a155246da87602071fa8283b4f42e1b4e9040b222be5f82622343ad2467b5cdf8003b02293e70ea8d391dc99f478ee36a1389311a9d4

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rucoa (0.8.0)
+    rucoa (0.9.0)
       parser
       rbs
       rubocop

data/lib/rucoa/definition_store.rb

@@ -2,26 +2,69 @@
 
 module Rucoa
   class DefinitionStore
-    # @return [Array<Rucoa::Definition::Base>]
-    attr_accessor :definitions
-
     def initialize
-      @definitions = []
+      @definition_by_full_qualified_name = {}
+      @fully_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
+    # @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
+      end
     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 source [Rucoa::Source]
+    # @return [void]
+    # @example resolves super class name correctly by using existent 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_fully_qualified_name('A::Bar')
+    #   expect(definition.super_class_fully_qualified_name).to eq('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
+    end
+
+    # @param fully_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]
     end
 
     # @param method_name [String]
@@ -30,20 +73,29 @@ module Rucoa
     # @return [Rucoa::Definition::MethodDefinition, nil]
     # @example has the ability to find `IO.write` from `File.write`
     #   definition_store = Rucoa::DefinitionStore.new
-    #   definition_store.definitions += Rucoa::DefinitionArchiver.load
+    #   definition_store.bulk_add(Rucoa::DefinitionArchiver.load)
     #   subject = definition_store.find_method_definition_by(
     #     method_name: 'write',
     #     namespace: 'File',
     #     singleton: true
     #   )
-    #   expect(subject.full_qualified_name).to eq('IO.write')
+    #   expect(subject.fully_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
+      definition = find_definition_by_fully_qualified_name(namespace)
+      return unless definition
+
+      [
+        namespace,
+        *ancestor_definitions_of(definition).map(&:fully_qualified_name)
+      ].find do |fully_qualified_name|
+        method_marker = singleton ? '.' : '#'
+        fully_qualified_method_name = [
+          fully_qualified_name,
+          method_marker,
+          method_name
+        ].join
+        definition = find_definition_by_fully_qualified_name(fully_qualified_method_name)
+        break definition if definition
       end
     end
 
@@ -51,28 +103,28 @@ 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(&:fully_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(&:fully_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_fully_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|
+      ].map(&:fully_qualified_name).flat_map do |fully_qualified_type_name|
         definitions.select do |definition|
-          definition.namespace == full_qualified_type_name
+          definition.namespace == fully_qualified_type_name
         end
       end
     end
@@ -81,29 +133,24 @@ 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(&:fully_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_fully_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|
+      ].map(&:fully_qualified_name).flat_map do |fully_qualified_type_name|
         definitions.select do |definition|
-          definition.namespace == full_qualified_type_name
+          definition.namespace == fully_qualified_type_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)
@@ -114,6 +161,15 @@ module Rucoa
 
     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)
+      end
+      @fully_qualified_names_by_uri.delete(source.uri)
+    end
+
     # @param type [String]
     # @return [String, nil]
     def singleton_class_name_from(type)
@@ -127,8 +183,8 @@ module Rucoa
 
       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)
+      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
 
         result << class_definition
@@ -136,17 +192,14 @@ module Rucoa
       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_full_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,12 +212,19 @@ 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
-      end
+    # @return [Array<Rucoa::Definition::ConstantDefinition>]
+    def constant_definitions
+      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
+
+      class_definition.super_class_candidates.find do |candidate|
+        find_definition_by_fully_qualified_name(candidate)
+      end || class_definition.super_class_chained_name
     end
   end
 end

data/lib/rucoa/definitions/class_definition.rb

@@ -3,13 +3,79 @@
 module Rucoa
   module Definitions
     class ClassDefinition < ModuleDefinition
+      # @return [Arra<String>, nil]
+      attr_reader :module_nesting
+
+      # @return [String, nil]
+      attr_reader :super_class_chained_name
+
       # @return [String, nil]
-      attr_reader :super_class_name
+      attr_accessor :super_class_fully_qualified_name
 
-      # @param super_class_name [String, nil]
-      def initialize(super_class_name:, **keyword_arguments)
+      # @param module_nesting [Array<String>, nil]
+      # @param super_class_chained_name [String, nil]
+      # @param super_class_fully_qualified_name [String, nil]
+      def initialize(
+        module_nesting: nil,
+        super_class_chained_name: nil,
+        super_class_fully_qualified_name: nil,
+        **keyword_arguments
+      )
         super(**keyword_arguments)
-        @super_class_name = super_class_name
+        @module_nesting = module_nesting
+        @super_class_chained_name = super_class_chained_name
+        @super_class_fully_qualified_name = super_class_fully_qualified_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]
       end
     end
   end

data/lib/rucoa/definitions/constant_definition.rb

@@ -5,23 +5,23 @@ module Rucoa
     # Represents class definition, module definition, or constant assignment.
     class ConstantDefinition < Base
       # @return [String]
-      attr_reader :full_qualified_name
+      attr_reader :fully_qualified_name
 
       # @return [String]
       attr_reader :source_path
 
-      # @param full_qualified_name [String]
+      # @param fully_qualified_name [String]
       # @param source_path [String]
-      def initialize(full_qualified_name:, source_path:)
+      def initialize(fully_qualified_name:, source_path:)
         super()
-        @full_qualified_name = full_qualified_name
+        @fully_qualified_name = fully_qualified_name
         @source_path = source_path
       end
 
       # @return [String]
       # @example returns non-full-qualified name
       #   definition = Rucoa::Definitions::ConstantDefinition.new(
-      #     full_qualified_name: 'Foo::Bar::Baz',
+      #     fully_qualified_name: 'Foo::Bar::Baz',
       #     source_path: '/path/to/foo/bar/baz.rb'
       #   )
       #   expect(definition.name).to eq('Baz')
@@ -32,7 +32,7 @@ module Rucoa
       # @return [String]
       # @example returns namespace
       #   definition = Rucoa::Definitions::ConstantDefinition.new(
-      #     full_qualified_name: 'Foo::Bar::Baz',
+      #     fully_qualified_name: 'Foo::Bar::Baz',
       #     source_path: '/path/to/foo/bar/baz.rb'
       #   )
       #   expect(definition.namespace).to eq('Foo::Bar')
@@ -44,7 +44,7 @@ module Rucoa
 
       # @return [Array<String>]
       def names
-        @names ||= full_qualified_name.split('::')
+        @names ||= fully_qualified_name.split('::')
       end
     end
   end

data/lib/rucoa/definitions/method_definition.rb

@@ -51,8 +51,8 @@ module Rucoa
       #     source_path: '/path/to/foo/bar.rb',
       #     types: []
       #   )
-      #   expect(method_definition.full_qualified_name).to eq('Foo::Bar#foo')
-      def full_qualified_name
+      #   expect(method_definition.fully_qualified_name).to eq('Foo::Bar#foo')
+      def fully_qualified_name
         [
           @namespace,
           method_kind_symbol,
@@ -105,8 +105,8 @@ module Rucoa
       def signatures
         @types.map do |type|
           format(
-            '%<full_qualified_name>s(%<parameters>s) -> %<return_types>s',
-            full_qualified_name: full_qualified_name,
+            '%<fully_qualified_name>s(%<parameters>s) -> %<return_types>s',
+            fully_qualified_name: fully_qualified_name,
             parameters: type.parameters_string,
             return_types: type.return_type
           )

data/lib/rucoa/handlers/initialized_handler.rb

@@ -7,16 +7,44 @@ module Rucoa
 
       def call
         request_workspace_configuration
-        load_definitions
+        update_source_store
+        update_definition_store
       end
 
       private
 
       # @return [void]
-      def load_definitions
-        Yard::DefinitionsLoader.load_globs(
-          globs: ::YARD::Parser::SourceParser::DEFAULT_PATH_GLOB
-        )
+      def update_definition_store
+        sources.each do |source|
+          definition_store.update_from(source)
+        end
+      end
+
+      # @return [void]
+      def update_source_store
+        sources.each do |source|
+          source_store.update(source)
+        end
+      end
+
+      # @return [Array<Rucoa::Source>]
+      def sources
+        @sources ||= pathnames.map do |pathname|
+          Source.new(
+            content: pathname.read,
+            uri: "file://#{pathname}"
+          )
+        end
+      end
+
+      # @return [Array<Pathname>]
+      def pathnames
+        ::Pathname.glob(glob)
+      end
+
+      # @return [String]
+      def glob
+        ::File.expand_path('{app,lib}/**/*.rb')
       end
     end
   end

data/lib/rucoa/handlers/text_document_completion_handler.rb

@@ -163,7 +163,7 @@ module Rucoa
       # @return [Rucoa::Node, nil]
       def node
         @node ||=
-          if source.syntax_error?
+          if source.failed_to_parse?
             repair
             repaired_node
           else

data/lib/rucoa/handlers/text_document_definition_handler.rb

@@ -94,8 +94,8 @@ module Rucoa
 
       # @return [Rucoa::Nodes::ClassNode, nil]
       def find_class_node
-        find_by_full_qualified_name(
-          full_qualified_name: definition.full_qualified_name,
+        find_by_fully_qualified_name(
+          fully_qualified_name: definition.fully_qualified_name,
           klass: Nodes::ClassNode
         ) || find_by_name(
           klass: Nodes::ClassNode,
@@ -105,8 +105,8 @@ module Rucoa
 
       # @return [Rucoa::Nodes::ModuleNode, nil]
       def find_module_node
-        find_by_full_qualified_name(
-          full_qualified_name: definition.full_qualified_name,
+        find_by_fully_qualified_name(
+          fully_qualified_name: definition.fully_qualified_name,
           klass: Nodes::ModuleNode
         ) || find_by_name(
           klass: Nodes::ModuleNode,
@@ -123,13 +123,13 @@ module Rucoa
         end
       end
 
-      # @param full_qualified_name [String]
+      # @param fully_qualified_name [String]
       # @param klass [Class]
       # @return [Rucoa::Nodes::Base, nil]
-      def find_by_full_qualified_name(full_qualified_name:, klass:)
+      def find_by_fully_qualified_name(fully_qualified_name:, klass:)
         location_root_or_descendant_nodes.reverse.find do |node|
           node.is_a?(klass) &&
-            node.full_qualified_name == full_qualified_name
+            node.fully_qualified_name == fully_qualified_name
         end
       end
 

data/lib/rucoa/handlers/text_document_did_open_handler.rb

@@ -7,10 +7,7 @@ module Rucoa
 
       def call
         source_store.update(source)
-        definition_store.update_definitions_defined_in(
-          source.path,
-          definitions: source.definitions
-        )
+        definition_store.update_from(source)
         publish_diagnostics_on(uri)
       end
 

data/lib/rucoa/node_concerns/{name_full_qualifiable.rb → name_fully_qualifiable.rb}

@@ -2,9 +2,9 @@
 
 module Rucoa
   module NodeConcerns
-    module NameFullQualifiable
+    module NameFullyQualifiable
       # @return [String]
-      def full_qualified_name
+      def fully_qualified_name
         [
           name,
           *each_ancestor(:class, :constant, :module).map(&:name)

data/lib/rucoa/node_concerns.rb

@@ -2,6 +2,6 @@
 
 module Rucoa
   module NodeConcerns
-    autoload :NameFullQualifiable, 'rucoa/node_concerns/name_full_qualifiable'
+    autoload :NameFullyQualifiable, 'rucoa/node_concerns/name_fully_qualifiable'
   end
 end

data/lib/rucoa/node_inspector.rb

@@ -90,20 +90,20 @@ module Rucoa
     def constant_definition
       return unless @node.is_a?(Nodes::ConstNode)
 
-      module_nesting_full_qualified_names = @node.each_ancestor(:class, :module).map(&:full_qualified_name)
-      candidate_full_qualified_names = module_nesting_full_qualified_names.flat_map do |module_nesting_full_qualified_name|
+      module_nesting = @node.module_nesting
+      candidate_fully_qualified_names = module_nesting.flat_map do |module_nesting_fully_qualified_name|
         [
-          module_nesting_full_qualified_name
-          # TODO: *ancestors_of(module_nesting_full_qualified_name)
-        ].map do |full_qualified_name|
+          module_nesting_fully_qualified_name
+          # TODO: *ancestors_of(module_nesting_fully_qualified_name)
+        ].map do |fully_qualified_name|
           [
-            full_qualified_name,
+            fully_qualified_name,
             @node.chained_name
           ].join('::')
         end
       end + [@node.chained_name]
-      candidate_full_qualified_names.find do |candidate_full_qualified_name|
-        definition = @definition_store.select_by_full_qualified_name(candidate_full_qualified_name).first
+      candidate_fully_qualified_names.find do |candidate_fully_qualified_name|
+        definition = @definition_store.find_definition_by_fully_qualified_name(candidate_fully_qualified_name)
         break definition if definition
       end
     end
@@ -114,20 +114,21 @@ module Rucoa
     end
 
     # @return [String, nil]
-    def nearest_def_full_qualified_name
-      @node.each_ancestor(:def).first&.full_qualified_name
+    def nearest_def_fully_qualified_name
+      @node.each_ancestor(:def).first&.fully_qualified_name
     end
 
     # @return [Array<String>]
     def return_types_for_lvar
-      full_qualified_name = nearest_def_full_qualified_name
-      return [] unless full_qualified_name
+      fully_qualified_name = nearest_def_fully_qualified_name
+      return [] unless fully_qualified_name
 
-      @definition_store.select_by_full_qualified_name(full_qualified_name).flat_map do |definition|
-        definition.parameters.select do |parameter|
-          parameter.name == @node.name
-        end.flat_map(&:types)
-      end
+      definition = @definition_store.find_definition_by_fully_qualified_name(fully_qualified_name)
+      return [] unless definition
+
+      definition.parameters.select do |parameter|
+        parameter.name == @node.name
+      end.flat_map(&:types)
     end
 
     # @return [Array<String>]