rucoa 0.6.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f31a0a81d1013267e3bfc0358911e1306e22f0b34f40249604050914da18d8f4
-  data.tar.gz: b999e9fe78ee1dbb0b11662756c84399b474fb8522476429c90becb454fb0fd1
+  metadata.gz: 26c4a8d526acb34d3722fc4b78e4c8fa0a1bac7bfc11d72af4b5962afdbc01c9
+  data.tar.gz: b49e5bdca272898e10870fbad7f99b2ba5cf63e0d1acef074d3af1928b69058b
 SHA512:
-  metadata.gz: 1af0f2fed0d7d7930f69768234263e77707f1f22d80e93392ae126c0cfa72d11b3356de6ba5c6f3476ff7b3f27239c1667ac1c2442e9e12301bdadb0a25fec47
-  data.tar.gz: bdd44ba9cb0284a16589798ec20ee7d9e9bf01989e054108859f3f8286a3f6382a45d84be056dd7a755de8b14d4cf9e28610652489e8e57f9c009b1f81c7f432
+  metadata.gz: 4de0736efd9d7b44d7756bfe5aedf6fc60d0b3a9ce9ab55cb0e3c6b83ca0525017e0ddb629d612ec4c05a8cae97f1d902bf33a3090c00570765c344821393bf6
+  data.tar.gz: 8228a81e3b4408274d2e51f2c339e724e4c4615f4af2a311bad68c48b74d32a09773cf5a0caaa780135780d7510b95aa64579ec6d009bf7fe711cb590660bde8

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rucoa (0.6.0)
+    rucoa (0.8.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

@@ -24,14 +24,86 @@ module Rucoa
       end
     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.definitions += 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')
+    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
+      end
+    end
+
+    # @param type [String]
+    # @return [Array<Rucoa::Definitions::MethodDefinition>]
+    # @example includes ancestors' methods
+    #   definition_store = Rucoa::DefinitionStore.new
+    #   definition_store.definitions += Rucoa::DefinitionArchiver.load
+    #   subject = definition_store.instance_method_definitions_of('File')
+    #   expect(subject.map(&:full_qualified_name)).to include('IO#raw')
+    # @example responds to `singleton<File>`
+    #   definition_store = Rucoa::DefinitionStore.new
+    #   definition_store.definitions += Rucoa::DefinitionArchiver.load
+    #   subject = definition_store.instance_method_definitions_of('singleton<File>')
+    #   expect(subject.map(&:full_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)
+      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
+        end
+      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 returns singleton method definitions of File
+    #   definition_store = Rucoa::DefinitionStore.new
+    #   definition_store.definitions += Rucoa::DefinitionArchiver.load
+    #   subject = definition_store.singleton_method_definitions_of('File')
+    #   expect(subject.map(&:full_qualified_name)).to include('IO.write')
+    def singleton_method_definitions_of(type)
+      class_or_module_definition = find_class_or_module_definition(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
+        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)
@@ -42,9 +114,34 @@ module Rucoa
 
     private
 
-    # @return [Array<Rucoa::Definition::ConstantDefinition>]
-    def constant_definitions
-      @definitions.grep(Definitions::ConstantDefinition)
+    # @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_name = class_definition.super_class_name)
+        class_definition = find_class_or_module_definition(super_class_name)
+        break unless class_definition
+
+        result << class_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
     end
 
     # @return [Array<Rucoa::Definition::MethodDefinition>]
@@ -52,6 +149,16 @@ module Rucoa
       @definitions.grep(Definitions::MethodDefinition)
     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
+
     # @param source_path [String]
     # @return [Array<Rucoa::Definition::Base>]
     def delete_definitions_defined_in(source_path)

data/lib/rucoa/definitions/class_definition.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Definitions
+    class ClassDefinition < ModuleDefinition
+      # @return [String, nil]
+      attr_reader :super_class_name
+
+      # @param super_class_name [String, nil]
+      def initialize(super_class_name:, **keyword_arguments)
+        super(**keyword_arguments)
+        @super_class_name = super_class_name
+      end
+    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
 
@@ -110,12 +113,21 @@ module Rucoa
         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/handler_concerns/diagnostics_publishable.rb

@@ -16,6 +16,18 @@ module Rucoa
         )
       end
 
+      # @param uri [String]
+      # @return [void]
+      def clear_diagnostics_on(uri)
+        write(
+          method: 'textDocument/publishDiagnostics',
+          params: {
+            diagnostics: [],
+            uri: uri
+          }
+        )
+      end
+
       # @param uri [String]
       # @return [void]
       def publish_diagnostics_on(uri)
@@ -48,7 +60,7 @@ module Rucoa
 
         # @return [Array<Hash>]
         def call
-          return [] unless RubocopConfigurationChecker.call
+          return [] unless Rubocop::ConfigurationChecker.call
 
           offenses.map do |offense|
             OffenseToDiagnosticMapper.call(
@@ -63,7 +75,7 @@ module Rucoa
 
         # @return [Array<RuboCop::Cop::Offense>]
         def offenses
-          RubocopInvestigator.call(source: @source)
+          Rubocop::Investigator.call(source: @source)
         end
 
         class OffenseToDiagnosticMapper

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

@@ -14,7 +14,7 @@ module Rucoa
 
       # @return [void]
       def load_definitions
-        YardGlobDocumentLoader.call(
+        Yard::DefinitionsLoader.load_globs(
           globs: ::YARD::Parser::SourceParser::DEFAULT_PATH_GLOB
         )
       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
 
@@ -208,7 +208,14 @@ module Rucoa
           if @repaired
             position.to_range
           else
-            Range.from_parser_range(node.location.expression)
+            Range.from_parser_range(
+              case node
+              when Nodes::SendNode
+                node.location.selector
+              else
+                node.location.expression
+              end
+            )
           end
       end
     end

data/lib/rucoa/handlers/text_document_definition_handler.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Handlers
+    class TextDocumentDefinitionHandler < Base
+      def call
+        respond(location)
+      end
+
+      private
+
+      # @return [Hash, nil]
+      def location
+        return unless reponsible?
+
+        {
+          range: location_range.to_vscode_range,
+          uri: location_uri
+        }
+      end
+
+      # @return [Boolean]
+      def reponsible?
+        configuration.enables_definition? &&
+          !location_uri.nil? &&
+          !location_source.nil?
+      end
+
+      # @return [Rucoa::Range]
+      def location_range
+        return Range.from_parser_range(location_node.location.expression) if location_node
+
+        Position.new.to_range
+      end
+
+      # @return [String, nil]
+      def location_uri
+        return unless definition
+
+        if definition.source_path.start_with?('Untitled-')
+          "untitled:#{definition.source_path}"
+        else
+          "file://#{definition.source_path}"
+        end
+      end
+
+      # @return [Rucoa::Nodes::Base, nil]
+      def location_node
+        @location_node ||=
+          case definition
+          when Definitions::ClassDefinition
+            find_class_node
+          when Definitions::ModuleDefinition
+            find_module_node
+          when Definitions::MethodDefinition
+            find_method_node
+          end
+      end
+
+      # @return [Rucoa::Source, nil]
+      def location_source
+        source_store.get(location_uri)
+      end
+
+      # @return [Rucoa::Position]
+      def position
+        Position.from_vscode_position(
+          request.dig('params', 'position')
+        )
+      end
+
+      # @return [String]
+      def uri
+        request.dig('params', 'textDocument', 'uri')
+      end
+
+      # @return [Rucoa::Source, nil]
+      def source
+        source_store.get(uri)
+      end
+
+      # @return [Rucoa::Nodes::Base]
+      def node
+        source&.node_at(position)
+      end
+
+      # @return [Rucoa::Definitions::Base, nil]
+      def definition
+        @definition ||= NodeInspector.new(
+          definition_store: definition_store,
+          node: node
+        ).definitions.first
+      end
+
+      # @return [Rucoa::Nodes::ClassNode, nil]
+      def find_class_node
+        find_by_full_qualified_name(
+          full_qualified_name: definition.full_qualified_name,
+          klass: Nodes::ClassNode
+        ) || find_by_name(
+          klass: Nodes::ClassNode,
+          name: definition.name
+        )
+      end
+
+      # @return [Rucoa::Nodes::ModuleNode, nil]
+      def find_module_node
+        find_by_full_qualified_name(
+          full_qualified_name: definition.full_qualified_name,
+          klass: Nodes::ModuleNode
+        ) || find_by_name(
+          klass: Nodes::ModuleNode,
+          name: definition.name
+        )
+      end
+
+      # @return [Rucoa::Nodes::MethodNode, nil]
+      def find_method_node
+        location_root_or_descendant_nodes.reverse.find do |node|
+          node.is_a?(Nodes::DefNode) &&
+            node.name == definition.method_name &&
+            node.namespace == definition.namespace
+        end
+      end
+
+      # @param full_qualified_name [String]
+      # @param klass [Class]
+      # @return [Rucoa::Nodes::Base, nil]
+      def find_by_full_qualified_name(full_qualified_name:, klass:)
+        location_root_or_descendant_nodes.reverse.find do |node|
+          node.is_a?(klass) &&
+            node.full_qualified_name == full_qualified_name
+        end
+      end
+
+      # @param name [String]
+      # @param klass [Class]
+      # @return [Rucoa::Nodes::Base, nil]
+      def find_by_name(klass:, name:)
+        location_root_or_descendant_nodes.reverse.find do |node|
+          node.is_a?(klass) &&
+            node.name == name
+        end
+      end
+
+      # @return [Array<Rucoa::Nodes::Base>]
+      def location_root_or_descendant_nodes
+        @location_root_or_descendant_nodes ||= [
+          location_source.root_node,
+          *location_source.root_node.descendants
+        ]
+      end
+    end
+  end
+end

data/lib/rucoa/handlers/text_document_did_close_handler.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Handlers
+    class TextDocumentDidCloseHandler < Base
+      include HandlerConcerns::DiagnosticsPublishable
+
+      def call
+        clear_diagnostics_on(uri)
+      end
+
+      private
+
+      # @return [String]
+      def uri
+        request.dig('params', 'textDocument', 'uri')
+      end
+    end
+  end
+end

data/lib/rucoa/handlers/text_document_formatting_handler.rb

@@ -13,7 +13,7 @@ module Rucoa
       def formattable?
         configuration.enables_formatting? &&
           source &&
-          RubocopConfigurationChecker.call
+          Rubocop::ConfigurationChecker.call
       end
 
       # @return [Array<Hash>]
@@ -43,7 +43,7 @@ module Rucoa
 
       # @return [String]
       def new_text
-        RubocopAutocorrector.call(source: source)
+        Rubocop::Autocorrector.call(source: source)
       end
 
       # @return [Hash]

data/lib/rucoa/handlers/text_document_hover_handler.rb

@@ -23,14 +23,13 @@ module Rucoa
       def responsible?
         configuration.enables_hover? &&
           !source.nil? &&
-          !node.nil?
+          !node.nil? &&
+          !method_definitions.empty?
       end
 
       # @return [String, nil]
       def contents
         method_definition = method_definitions.first
-        return unless method_definition
-
         [
           method_definition.signatures.join("\n"),
           method_definition.description
@@ -66,7 +65,7 @@ module Rucoa
 
       # @return [Array<Rucoa::Definitions::MethodDefinition>]
       def method_definitions
-        NodeInspector.new(
+        @method_definitions ||= NodeInspector.new(
           definition_store: definition_store,
           node: node
         ).method_definitions

data/lib/rucoa/handlers/text_document_range_formatting_handler.rb

@@ -25,7 +25,7 @@ module Rucoa
       def formattable?
         configuration.enables_formatting? &&
           source &&
-          RubocopConfigurationChecker.call
+          Rubocop::ConfigurationChecker.call
       end
 
       # @return [Rucoa::Source]
@@ -59,7 +59,7 @@ module Rucoa
 
       # @return [Array<RuboCop::Cop::Offense>]
       def offenses
-        RubocopInvestigator.call(source: source)
+        Rubocop::Investigator.call(source: source)
       end
 
       # @return [Array(Rucoa::Range, String)]

data/lib/rucoa/handlers.rb

@@ -9,7 +9,9 @@ module Rucoa
     autoload :ShutdownHandler, 'rucoa/handlers/shutdown_handler'
     autoload :TextDocumentCodeActionHandler, 'rucoa/handlers/text_document_code_action_handler'
     autoload :TextDocumentCompletionHandler, 'rucoa/handlers/text_document_completion_handler'
+    autoload :TextDocumentDefinitionHandler, 'rucoa/handlers/text_document_definition_handler'
     autoload :TextDocumentDidChangeHandler, 'rucoa/handlers/text_document_did_change_handler'
+    autoload :TextDocumentDidCloseHandler, 'rucoa/handlers/text_document_did_close_handler'
     autoload :TextDocumentDidOpenHandler, 'rucoa/handlers/text_document_did_open_handler'
     autoload :TextDocumentDocumentSymbolHandler, 'rucoa/handlers/text_document_document_symbol_handler'
     autoload :TextDocumentFormattingHandler, 'rucoa/handlers/text_document_formatting_handler'