rucoa 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48f65475f89a895b8fa3429ddcb5a10738c78e2181a0a0f41a8fe14ec8a2fd17
-  data.tar.gz: b94bffab0ae35cf83ee0ae5146f41b583abcea4b4192eabcdc8acbcedf3418b4
+  metadata.gz: 26c4a8d526acb34d3722fc4b78e4c8fa0a1bac7bfc11d72af4b5962afdbc01c9
+  data.tar.gz: b49e5bdca272898e10870fbad7f99b2ba5cf63e0d1acef074d3af1928b69058b
 SHA512:
-  metadata.gz: 1693536178207fc2740ede4806a8803f140477b312c143e7ad0284875c1685244a09fa33dcd6208e993f4d0acb87284391a605a27e09d8479c71f556cf951d7f
-  data.tar.gz: d4458ea8223b032e5df2680bfa4f8ed2f939f2971a19db327306a3c6fb6a9a6b3810ffd8ed56346b6e7defb36b916e9054bcb71d031f2494c30b0d6f216995eb
+  metadata.gz: 4de0736efd9d7b44d7756bfe5aedf6fc60d0b3a9ce9ab55cb0e3c6b83ca0525017e0ddb629d612ec4c05a8cae97f1d902bf33a3090c00570765c344821393bf6
+  data.tar.gz: 8228a81e3b4408274d2e51f2c339e724e4c4615f4af2a311bad68c48b74d32a09773cf5a0caaa780135780d7510b95aa64579ec6d009bf7fe711cb590660bde8

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rucoa (0.7.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/handlers/initialize_handler.rb

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

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
 

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_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.rb

@@ -9,6 +9,7 @@ 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'

data/lib/rucoa/node_inspector.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
-
 module Rucoa
   class NodeInspector
     # @param definition_store [Rucoa::DefinitionStore]
@@ -11,10 +9,24 @@ module Rucoa
       @node = node
     end
 
-    # @return [Array<String>]
+    # @return [Array<Rucoa::Definitions::Base>]
+    def definitions
+      case @node
+      when Nodes::ConstNode
+        [constant_definition]
+      when Nodes::SendNode
+        method_definitions
+      else
+        []
+      end
+    end
+
+    # @return [Array<Rucoa::Definitions::MethodDefinition>]
     def method_definitions
-      method_full_qualified_names.flat_map do |full_qualified_name|
-        @definition_store.select_by_full_qualified_name(full_qualified_name)
+      method_receiver_types.flat_map do |type|
+        @definition_store.instance_method_definitions_of(type)
+      end.select do |method_definition|
+        method_definition.method_name == @node.name
       end
     end
 
@@ -36,7 +48,7 @@ module Rucoa
     def return_types
       case @node.type
       when :const
-        [@node.name]
+        ["singleton<#{@node.name}>"]
       when :lvar
         return_types_for_lvar
       when :send
@@ -74,26 +86,31 @@ module Rucoa
 
     private
 
-    # @return [Array<String>]
-    def method_full_qualified_names
-      method_receiver_types.map do |type|
+    # @return [Rucoa::Definitions::ConstantDefinition, nil]
+    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|
         [
-          type,
-          @node.name
-        ].join(method_kind_symbol)
+          module_nesting_full_qualified_name
+          # TODO: *ancestors_of(module_nesting_full_qualified_name)
+        ].map do |full_qualified_name|
+          [
+            full_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
+        break definition if definition
       end
     end
 
-    # @return [String, nil]
-    def method_kind_symbol
-      return unless @node.is_a?(Nodes::SendNode)
-
-      case @node.receiver
-      when Nodes::ConstNode
-        '.'
-      else
-        '#'
-      end
+    # @return [Boolean]
+    def singleton_method_call?
+      @node.is_a?(Nodes::ConstNode)
     end
 
     # @return [String, nil]
@@ -115,9 +132,13 @@ module Rucoa
 
     # @return [Array<String>]
     def return_types_for_send
-      method_full_qualified_names.flat_map do |full_qualified_name|
-        @definition_store.select_by_full_qualified_name(full_qualified_name).flat_map(&:return_types)
-      end.uniq
+      method_receiver_types.flat_map do |type|
+        @definition_store.find_method_definition_by(
+          method_name: @node.name,
+          namespace: type,
+          singleton: singleton_method_call?
+        )&.return_types
+      end.compact
     end
   end
 end

data/lib/rucoa/nodes/base.rb

@@ -121,8 +121,8 @@ module Rucoa
       # @param types [Array<Symbol>]
       # @return [void]
       def visit_descendants(types, &block)
-        each_child_node(*types) do |child|
-          yield(child)
+        each_child_node do |child|
+          yield(child) if types.empty? || types.include?(child.type)
           child.visit_descendants(types, &block)
         end
       end

data/lib/rucoa/nodes/const_node.rb

@@ -4,9 +4,40 @@ module Rucoa
   module Nodes
     class ConstNode < Base
       # @return [String]
+      # @example returns "A" for "A"
+      #   node = Rucoa::Parser.call('A')
+      #   expect(node.name).to eq('A')
+      # @example returns "B" for "A::B"
+      #   node = Rucoa::Parser.call('A::B')
+      #   expect(node.name).to eq('B')
       def name
         children[1].to_s
       end
+
+      # @return [String]
+      # @example returns "A" for "A"
+      #   node = Rucoa::Parser.call('A')
+      #   expect(node.chained_name).to eq('A')
+      # @example returns "A::B" for "A::B"
+      #   node = Rucoa::Parser.call('A::B')
+      #   expect(node.chained_name).to eq('A::B')
+      def chained_name
+        if receiver.is_a?(ConstNode)
+          [
+            receiver.chained_name,
+            name
+          ].join('::')
+        else
+          name
+        end
+      end
+
+      private
+
+      # @return [Rucoa::Nodes::Base, nil]
+      def receiver
+        children[0]
+      end
     end
   end
 end

data/lib/rucoa/position.rb

@@ -39,7 +39,7 @@ module Rucoa
 
     # @param column [Integer] 0-origin column number
     # @param line [Integer] 1-origin line number
-    def initialize(column:, line:)
+    def initialize(column: 0, line: 1)
       @column = column
       @line = line
     end

data/lib/rucoa/rbs/class_definition_mapper.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Rbs
+    class ClassDefinitionMapper
+      class << self
+        # @param declaration [RBS::AST::Declarations::Class]
+        # @return [Rucoa::Definitions::ClassDefinition]
+        def call(declaration:)
+          new(declaration: declaration).call
+        end
+      end
+
+      # @param declaration [RBS::AST::Declarations::Class]
+      def initialize(declaration:)
+        @declaration = declaration
+      end
+
+      # @return [Rucoa::Definitions::ClassDefinition]
+      def call
+        Definitions::ClassDefinition.new(
+          full_qualified_name: full_qualified_name,
+          source_path: source_path,
+          super_class_name: super_class_name
+        )
+      end
+
+      private
+
+      # @return [String]
+      def full_qualified_name
+        @declaration.name.to_s.delete_prefix('::')
+      end
+
+      # @return [String]
+      def source_path
+        @declaration.location.name
+      end
+
+      # @return [String, nil]
+      def super_class_name
+        @declaration.super_class&.name&.to_s&.delete_prefix('::')
+      end
+    end
+  end
+end

data/lib/rucoa/rbs/module_definition_mapper.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Rbs
+    class ModuleDefinitionMapper
+      class << self
+        # @param declaration [RBS::AST::Declarations::Module]
+        # @return [Rucoa::Definitions::ModuleDefinition]
+        def call(declaration:)
+          new(declaration: declaration).call
+        end
+      end
+
+      # @param declaration [RBS::AST::Declarations::Module]
+      def initialize(declaration:)
+        @declaration = declaration
+      end
+
+      # @return [Rucoa::Definitions::ModuleDefinition]
+      def call
+        Definitions::ModuleDefinition.new(
+          full_qualified_name: full_qualified_name,
+          source_path: source_path
+        )
+      end
+
+      private
+
+      # @return [String]
+      def full_qualified_name
+        @declaration.name.to_s.delete_prefix('::')
+      end
+
+      # @return [String]
+      def source_path
+        @declaration.location.name
+      end
+    end
+  end
+end

data/lib/rucoa/rbs/ruby_definitions_loader.rb

@@ -18,13 +18,17 @@ module Rucoa
         declarations.flat_map do |declaration|
           case declaration
           when ::RBS::AST::Declarations::Constant
-            [
-              ConstantDefinitionMapper.call(declaration: declaration)
-            ]
-          when ::RBS::AST::Declarations::Class, ::RBS::AST::Declarations::Module
-            [
-              ConstantDefinitionMapper.call(declaration: declaration)
-            ] +
+            [ConstantDefinitionMapper.call(declaration: declaration)]
+          when ::RBS::AST::Declarations::Class
+            [ClassDefinitionMapper.call(declaration: declaration)] +
+              declaration.members.grep(::RBS::AST::Members::MethodDefinition).map do |method_definition|
+                MethodDefinitionMapper.call(
+                  declaration: declaration,
+                  method_definition: method_definition
+                )
+              end
+          when ::RBS::AST::Declarations::Module
+            [ModuleDefinitionMapper.call(declaration: declaration)] +
               declaration.members.grep(::RBS::AST::Members::MethodDefinition).map do |method_definition|
                 MethodDefinitionMapper.call(
                   declaration: declaration,

data/lib/rucoa/rbs.rb

@@ -2,8 +2,10 @@
 
 module Rucoa
   module Rbs
+    autoload :ClassDefinitionMapper, 'rucoa/rbs/class_definition_mapper'
     autoload :ConstantDefinitionMapper, 'rucoa/rbs/constant_definition_mapper'
     autoload :MethodDefinitionMapper, 'rucoa/rbs/method_definition_mapper'
+    autoload :ModuleDefinitionMapper, 'rucoa/rbs/module_definition_mapper'
     autoload :RubyDefinitionsLoader, 'rucoa/rbs/ruby_definitions_loader'
   end
 end

data/lib/rucoa/rubocop/autocorrector.rb

@@ -32,9 +32,20 @@ module Rucoa
       # @return [String]
       def call
         @options[:stdin] = @source.content
-        run([@source.path || 'untitled'])
+        run([path])
         @options[:stdin]
       end
+
+      private
+
+      # @return [String]
+      def path
+        if @source.untitled? || @source.path.nil?
+          'untitled'
+        else
+          @source.path
+        end
+      end
     end
   end
 end

data/lib/rucoa/rubocop/investigator.rb

@@ -32,7 +32,7 @@ module Rucoa
       # @return [Array<RuboCop::Cop::Offense>]
       def call
         @options[:stdin] = @source.content
-        run([@source.path || 'untitled'])
+        run([path])
         @offenses
       end
 
@@ -45,6 +45,15 @@ module Rucoa
         @offenses = offenses
         super
       end
+
+      # @return [String]
+      def path
+        if @source.untitled? || @source.path.nil?
+          'untitled'
+        else
+          @source.path
+        end
+      end
     end
   end
 end

data/lib/rucoa/server.rb

@@ -13,6 +13,7 @@ module Rucoa
       'shutdown' => Handlers::ShutdownHandler,
       'textDocument/codeAction' => Handlers::TextDocumentCodeActionHandler,
       'textDocument/completion' => Handlers::TextDocumentCompletionHandler,
+      'textDocument/definition' => Handlers::TextDocumentDefinitionHandler,
       'textDocument/didChange' => Handlers::TextDocumentDidChangeHandler,
       'textDocument/didClose' => Handlers::TextDocumentDidCloseHandler,
       'textDocument/didOpen' => Handlers::TextDocumentDidOpenHandler,

data/lib/rucoa/source.rb

@@ -29,6 +29,7 @@ module Rucoa
     #   )
     #   expect(source.definitions).to match(
     #     [
+    #       a_kind_of(Rucoa::Definitions::ClassDefinition),
     #       a_kind_of(Rucoa::Definitions::MethodDefinition)
     #     ]
     #   )
@@ -46,15 +47,17 @@ module Rucoa
     #     uri: 'file:///path/to/foo.rb'
     #   )
     #   expect(source.path).to eq('/path/to/foo.rb')
-    # @example returns nil for untitled URI
+    # @example returns name for untitled URI
     #   source = Rucoa::Source.new(
     #     content: '',
     #     uri: 'untitled:Untitled-1'
     #   )
-    #   expect(source.path).to be_nil
+    #   expect(source.path).to eq('Untitled-1')
     def path
       return unless @uri
 
+      return @uri.split(':', 2).last if untitled?
+
       path = ::URI.parse(@uri).path
       return unless path
 
@@ -83,6 +86,11 @@ module Rucoa
       root_node.nil?
     end
 
+    # @return [Boolean]
+    def untitled?
+      @uri&.start_with?('untitled:')
+    end
+
     private
 
     # @return [Array<Rucoa::Nodes::Base>]

data/lib/rucoa/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rucoa
-  VERSION = '0.7.0'
+  VERSION = '0.8.0'
 end

data/lib/rucoa/yard/definitions_loader.rb

@@ -24,35 +24,58 @@ module Rucoa
         #     content: content,
         #     path: '/path/to/foo.rb'
         #   )
-        #   expect(definitions.size).to eq(1)
-        #   expect(definitions.first.full_qualified_name).to eq('Foo#foo')
-        #   expect(definitions.first.source_path).to eq('/path/to/foo.rb')
-        #   expect(definitions.first.description).to eq('Return given argument as an Integer.')
-        #   expect(definitions.first.return_types).to eq(%w[Integer])
+        #   expect(definitions.size).to eq(2)
+        #   expect(definitions[1].full_qualified_name).to eq('Foo#foo')
+        #   expect(definitions[1].source_path).to eq('/path/to/foo.rb')
+        #   expect(definitions[1].description).to eq('Return given argument as an Integer.')
+        #   expect(definitions[1].return_types).to eq(%w[Integer])
         def load_string(content:, path:)
-          ::YARD::Registry.clear
-          quietly do
+          load(path: path) do
             ::YARD.parse_string(content)
           end
-          ::YARD::Registry.all.filter_map do |code_object|
-            DefinitionMapper.call(code_object, path: path)
-          end
         end
 
         # @param globs [String]
         # @return [Array<Rucoa::Definitions::Base>]
         def load_globs(globs:)
-          ::YARD::Registry.clear
-          quietly do
+          load do
             ::YARD.parse(globs)
           end
-          ::YARD::Registry.all.filter_map do |code_object|
-            DefinitionMapper.call(code_object)
-          end
         end
 
         private
 
+        # @param code_object [YARD::CodeObjects::Base]
+        # @param path [String, nil]
+        # @return [Rucoa::Definitions::Base, nil]
+        def map(code_object, path:)
+          case code_object
+          when ::YARD::CodeObjects::ClassObject
+            Definitions::ClassDefinition.new(
+              full_qualified_name: code_object.path,
+              source_path: path || code_object.file,
+              super_class_name: code_object.superclass.to_s # TODO: superclass may not include full namespace on `YARD.parse_string`.
+            )
+          when ::YARD::CodeObjects::ModuleObject
+            Definitions::ModuleDefinition.new(
+              full_qualified_name: code_object.path,
+              source_path: path || code_object.file
+            )
+          when ::YARD::CodeObjects::MethodObject
+            MethodDefinitionMapper.call(code_object, path: path)
+          end
+        end
+
+        # @param path [String, nil]
+        # @return [Array<Rucoa::Definitions::Base>]
+        def load(path: nil, &block)
+          ::YARD::Registry.clear
+          quietly(&block)
+          ::YARD::Registry.all.filter_map do |code_object|
+            map(code_object, path: path)
+          end
+        end
+
         def quietly(&block)
           ::YARD::Logger.instance.enter_level(::Logger::FATAL, &block)
         end

data/lib/rucoa/yard/{definition_mapper.rb → method_definition_mapper.rb}

@@ -4,9 +4,9 @@ require 'yard'
 
 module Rucoa
   module Yard
-    class DefinitionMapper
+    class MethodDefinitionMapper
       class << self
-        # @param code_object [YARD::CodeObjects::Base]
+        # @param code_object [YARD::CodeObjects::MethodObject]
         # @param path [String] This must be passed if the path is not available from code object.
         # @return [Rucoa::Definitions::Base, nil]
         def call(code_object, path: code_object.file)
@@ -14,17 +14,15 @@ module Rucoa
         end
       end
 
-      # @param code_object [YARD::CodeObjects::Base]
+      # @param code_object [YARD::CodeObjects::MethodObject]
       # @param path [String]
       def initialize(code_object, path:)
         @code_object = code_object
         @path = path
       end
 
-      # @return [Rucoa::Definitions::Base, nil]
+      # @return [Rucoa::Definitions::MethodDefinition]
       def call
-        return unless @code_object.is_a?(::YARD::CodeObjects::MethodObject)
-
         Definitions::MethodDefinition.new(
           description: description,
           kind: kind,
@@ -51,9 +49,9 @@ module Rucoa
         end
       end
 
-      # @return [String
+      # @return [String]
       def method_name
-        @code_object.name
+        @code_object.name.to_s
       end
 
       # @return [String]
@@ -90,7 +88,7 @@ module Rucoa
       #     RUBY
       #     path: '/path/to/foo.rb'
       #   )
-      #   expect(definitions.first.signatures).to eq(
+      #   expect(definitions[1].signatures).to eq(
       #     [
       #       'Foo#bar(argument1, argument2 = nil, *arguments, keyword1:, keyword2: nil, **keywords, &block) -> Object'
       #     ]
@@ -115,7 +113,7 @@ module Rucoa
       # @return [Array<Rucoa::Definitions::MethodParameterDefinition>]
       def parameters
         parameter_tags.map do |parameter_tag|
-          ::Rucoa::Definitions::MethodParameterDefinition.new(
+          Definitions::MethodParameterDefinition.new(
             name: parameter_tag.name,
             types: parameter_tag.types
           )
@@ -180,27 +178,27 @@ module Rucoa
 
         # @return [String]
         # @example scrubs "Array<String>" to "Array"
-        #   yard_type = Rucoa::Yard::DefinitionMapper::YardType.new(
+        #   yard_type = Rucoa::Yard::MethodDefinitionMapper::YardType.new(
         #     'Array<String>'
         #   )
         #   expect(yard_type.to_rucoa_type).to eq('Array')
         # @example scrubs "Array(String, Integer)" to "Array"
-        #   yard_type = Rucoa::Yard::DefinitionMapper::YardType.new(
+        #   yard_type = Rucoa::Yard::MethodDefinitionMapper::YardType.new(
         #     'Array(String, Integer)'
         #   )
         #   expect(yard_type.to_rucoa_type).to eq('Array')
         # @example scrubs "::Array" to "Array"
-        #   yard_type = Rucoa::Yard::DefinitionMapper::YardType.new(
+        #   yard_type = Rucoa::Yard::MethodDefinitionMapper::YardType.new(
         #     '::Array'
         #   )
         #   expect(yard_type.to_rucoa_type).to eq('Array')
         # @example scrubs "Hash{Symbol => Object}" to "Hash"
-        #   yard_type = Rucoa::Yard::DefinitionMapper::YardType.new(
+        #   yard_type = Rucoa::Yard::MethodDefinitionMapper::YardType.new(
         #     'Hash{Symbol => Object}'
         #   )
         #   expect(yard_type.to_rucoa_type).to eq('Hash')
         # @example scrubs "Array<Array<Integer>>" to "Array"
-        #   yard_type = Rucoa::Yard::DefinitionMapper::YardType.new(
+        #   yard_type = Rucoa::Yard::MethodDefinitionMapper::YardType.new(
         #     'Array<Array<Integer>>'
         #   )
         #   expect(yard_type.to_rucoa_type).to eq('Array')

data/lib/rucoa/yard.rb

@@ -2,7 +2,7 @@
 
 module Rucoa
   module Yard
-    autoload :DefinitionMapper, 'rucoa/yard/definition_mapper'
     autoload :DefinitionsLoader, 'rucoa/yard/definitions_loader'
+    autoload :MethodDefinitionMapper, 'rucoa/yard/method_definition_mapper'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rucoa
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Ryo Nakamura
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-09-15 00:00:00.000000000 Z
+date: 2022-09-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -95,9 +95,11 @@ files:
 - lib/rucoa/definition_store.rb
 - lib/rucoa/definitions.rb
 - lib/rucoa/definitions/base.rb
+- lib/rucoa/definitions/class_definition.rb
 - lib/rucoa/definitions/constant_definition.rb
 - lib/rucoa/definitions/method_definition.rb
 - lib/rucoa/definitions/method_parameter_definition.rb
+- lib/rucoa/definitions/module_definition.rb
 - lib/rucoa/errors.rb
 - lib/rucoa/handler_concerns.rb
 - lib/rucoa/handler_concerns/configuration_requestable.rb
@@ -110,6 +112,7 @@ files:
 - lib/rucoa/handlers/shutdown_handler.rb
 - lib/rucoa/handlers/text_document_code_action_handler.rb
 - lib/rucoa/handlers/text_document_completion_handler.rb
+- lib/rucoa/handlers/text_document_definition_handler.rb
 - lib/rucoa/handlers/text_document_did_change_handler.rb
 - lib/rucoa/handlers/text_document_did_close_handler.rb
 - lib/rucoa/handlers/text_document_did_open_handler.rb
@@ -143,8 +146,10 @@ files:
 - lib/rucoa/position.rb
 - lib/rucoa/range.rb
 - lib/rucoa/rbs.rb
+- lib/rucoa/rbs/class_definition_mapper.rb
 - lib/rucoa/rbs/constant_definition_mapper.rb
 - lib/rucoa/rbs/method_definition_mapper.rb
+- lib/rucoa/rbs/module_definition_mapper.rb
 - lib/rucoa/rbs/ruby_definitions_loader.rb
 - lib/rucoa/rubocop.rb
 - lib/rucoa/rubocop/autocorrector.rb
@@ -157,8 +162,8 @@ files:
 - lib/rucoa/types/method_type.rb
 - lib/rucoa/version.rb
 - lib/rucoa/yard.rb
-- lib/rucoa/yard/definition_mapper.rb
 - lib/rucoa/yard/definitions_loader.rb
+- lib/rucoa/yard/method_definition_mapper.rb
 - rucoa.gemspec
 homepage: https://github.com/r7kamura/rucoa
 licenses: