rucoa 0.7.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48f65475f89a895b8fa3429ddcb5a10738c78e2181a0a0f41a8fe14ec8a2fd17
-  data.tar.gz: b94bffab0ae35cf83ee0ae5146f41b583abcea4b4192eabcdc8acbcedf3418b4
+  metadata.gz: 237fa68185426d66437c43fc2a3f34f7f85ee7309eb4ed6bb6ce4e31b5dfbb6e
+  data.tar.gz: e9f96daf65c7ccef564b2e06756497fd4d98bd946911487ca2fdd32740436e4b
 SHA512:
-  metadata.gz: 1693536178207fc2740ede4806a8803f140477b312c143e7ad0284875c1685244a09fa33dcd6208e993f4d0acb87284391a605a27e09d8479c71f556cf951d7f
-  data.tar.gz: d4458ea8223b032e5df2680bfa4f8ed2f939f2971a19db327306a3c6fb6a9a6b3810ffd8ed56346b6e7defb36b916e9054bcb71d031f2494c30b0d6f216995eb
+  metadata.gz: 3698e9db246d46ce64314df9b4a7418278a6e9f65cc2e80dfece624b547c5ab238af42b456370d1096e872f6e30aefdb132b5b2bd435ec03d1e6cccdac0a908a
+  data.tar.gz: 5088d4dcc1fa5ad6e053a155246da87602071fa8283b4f42e1b4e9040b222be5f82622343ad2467b5cdf8003b02293e70ea8d391dc99f478ee36a1389311a9d4

data/Gemfile.lock

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

data/README.md

@@ -62,6 +62,10 @@ This extension supports the folowiing types of symbols:
 
 Provides completion items for constant names and method names.
 
+### Definition
+
+Provides "Go to Definition" command to jump to the definition.
+
 ### Hover
 
 Shows documentation for the symbol under the cursor.
@@ -72,6 +76,5 @@ Shows method signature help when you start to type method arguments like `"100".
 
 ## Coming soon
 
-- Go to Definition
 - Highlight
 - Semantic Tokens

data/lib/rucoa/configuration.rb

@@ -16,6 +16,11 @@ module Rucoa
       disable_feature('completion')
     end
 
+    # @return [void]
+    def disable_definition
+      disable_feature('definition')
+    end
+
     # @return [void]
     def disable_diagnostics
       disable_feature('diagnostics')
@@ -82,6 +87,11 @@ module Rucoa
       enables_feature?('completion')
     end
 
+    # @return [Boolean]
+    def enables_definition?
+      enables_feature?('definition')
+    end
+
     # @return [Boolean]
     def enables_diagnostics?
       enables_feature?('diagnostics')

data/lib/rucoa/definition_store.rb

@@ -2,33 +2,152 @@
 
 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]
     # @param namespace [String]
+    # @param singleton [Boolean]
+    # @return [Rucoa::Definition::MethodDefinition, nil]
+    # @example has the ability to find `IO.write` from `File.write`
+    #   definition_store = Rucoa::DefinitionStore.new
+    #   definition_store.bulk_add(Rucoa::DefinitionArchiver.load)
+    #   subject = definition_store.find_method_definition_by(
+    #     method_name: 'write',
+    #     namespace: 'File',
+    #     singleton: true
+    #   )
+    #   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)
+      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
+
+    # @param type [String]
     # @return [Array<Rucoa::Definitions::MethodDefinition>]
-    def method_definitions_of(namespace)
-      method_definitions.select do |method_definition|
-        method_definition.namespace == namespace
+    # @example includes ancestors' methods
+    #   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')
+    # @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')
+    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)
+      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
+        end
+      end
+    end
+
+    # @param type [String]
+    # @return [Array<Rucoa::Definitions::MethodDefinition>]
+    # @example returns singleton method definitions of File
+    #   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')
+    def singleton_method_definitions_of(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(&:fully_qualified_name).flat_map do |fully_qualified_type_name|
+        definitions.select do |definition|
+          definition.namespace == fully_qualified_type_name
+        end
       end
     end
 
@@ -42,22 +161,70 @@ module Rucoa
 
     private
 
-    # @return [Array<Rucoa::Definition::ConstantDefinition>]
-    def constant_definitions
-      @definitions.grep(Definitions::ConstantDefinition)
+    # @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)
+      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)
+
+      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
+
+        result << class_definition
+      end
+      result
+    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
 
-    # @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::MethodDefinition>]
+    def instance_method_definitions
+      method_definitions.select(&:instance_method?)
+    end
+
+    # @return [Array<Rucoa::Definition::MethodDefinition>]
+    def singleton_method_definitions
+      method_definitions.select(&:singleton_method?)
+    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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+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_accessor :super_class_fully_qualified_name
+
+      # @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)
+        @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
+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

@@ -6,6 +6,9 @@ module Rucoa
       # @return [String, nil]
       attr_reader :description
 
+      # @return [Symbol]
+      attr_reader :kind
+
       # @return [String]
       attr_reader :method_name
 
@@ -48,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,
@@ -102,20 +105,29 @@ 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
           )
         end
       end
 
+      # @return [Boolean]
+      def instance_method?
+        @kind == :instance
+      end
+
+      # @return [Boolean]
+      def singleton_method?
+        !instance_method?
+      end
+
       private
 
       # @return [String]
       def method_kind_symbol
-        case @kind
-        when :instance
+        if instance_method?
           '#'
         else
           '.'

data/lib/rucoa/definitions/module_definition.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Definitions
+    class ModuleDefinition < ConstantDefinition
+    end
+  end
+end

data/lib/rucoa/definitions.rb

@@ -3,7 +3,9 @@
 module Rucoa
   module Definitions
     autoload :Base, 'rucoa/definitions/base'
+    autoload :ClassDefinition, 'rucoa/definitions/class_definition'
     autoload :ConstantDefinition, 'rucoa/definitions/constant_definition'
     autoload :MethodDefinition, 'rucoa/definitions/method_definition'
+    autoload :ModuleDefinition, 'rucoa/definitions/module_definition'
   end
 end

data/lib/rucoa/handlers/initialize_handler.rb

@@ -13,6 +13,7 @@ module Rucoa
                 .
               ]
             },
+            definitionProvider: true,
             documentFormattingProvider: true,
             documentRangeFormattingProvider: true,
             documentSymbolProvider: true,

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

@@ -148,7 +148,7 @@ module Rucoa
       # @return [Array<String>]
       def callable_method_definitions
         receiver_types.flat_map do |type|
-          definition_store.method_definitions_of(type)
+          definition_store.instance_method_definitions_of(type)
         end
       end
 
@@ -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