rucoa 0.7.0 → 0.9.0

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_fully_qualified_name(
+          fully_qualified_name: definition.fully_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_fully_qualified_name(
+          fully_qualified_name: definition.fully_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 fully_qualified_name [String]
+      # @param klass [Class]
+      # @return [Rucoa::Nodes::Base, nil]
+      def find_by_fully_qualified_name(fully_qualified_name:, klass:)
+        location_root_or_descendant_nodes.reverse.find do |node|
+          node.is_a?(klass) &&
+            node.fully_qualified_name == fully_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_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/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_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

@@ -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,50 +86,60 @@ 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 = @node.module_nesting
+      candidate_fully_qualified_names = module_nesting.flat_map do |module_nesting_fully_qualified_name|
         [
-          type,
-          @node.name
-        ].join(method_kind_symbol)
+          module_nesting_fully_qualified_name
+          # TODO: *ancestors_of(module_nesting_fully_qualified_name)
+        ].map do |fully_qualified_name|
+          [
+            fully_qualified_name,
+            @node.chained_name
+          ].join('::')
+        end
+      end + [@node.chained_name]
+      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
 
-    # @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]
-    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>]
     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

@@ -89,7 +89,7 @@ module Rucoa
       # @return [String]
       # @example returns namespace
       #   node = Rucoa::Source.new(
-      #     content: <<~RUBY
+      #     content: <<~RUBY,
       #       module Foo
       #         class Bar
       #           def baz
@@ -97,6 +97,7 @@ module Rucoa
       #         end
       #       end
       #     RUBY
+      #     uri: 'file:///path/to/foo/bar.rb'
       #   ).node_at(
       #     Rucoa::Position.new(
       #       column: 4,
@@ -105,14 +106,38 @@ module Rucoa
       #   )
       #   expect(node.namespace).to eq('Foo::Bar')
       # @example returns "Object" when the node is not in a namespace
-      #   node = Rucoa::Parser.call(
-      #     <<~RUBY
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY,
       #       foo
       #     RUBY
-      #   )
+      #     uri: 'file:///path/to/example.rb'
+      #   ).root_node
       #   expect(node.namespace).to eq('Object')
       def namespace
-        each_ancestor(:module, :class).first&.full_qualified_name || 'Object'
+        module_nesting.first || 'Object'
+      end
+
+      # @return [Array<String>]
+      # @example return ["Bar::Foo", "Foo"] for class Foo::Bar::Baz
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY,
+      #       module Foo
+      #         module Bar
+      #           module Baz
+      #           end
+      #         end
+      #       end
+      #     RUBY
+      #     uri: 'file:///path/to/foo/bar/baz.rb'
+      #   ).node_at(
+      #     Rucoa::Position.new(
+      #       column: 4,
+      #       line: 3
+      #     )
+      #   )
+      #   expect(node.module_nesting).to eq(['Foo::Bar', 'Foo'])
+      def module_nesting
+        each_ancestor(:class, :module).map(&:fully_qualified_name)
       end
 
       protected
@@ -121,8 +146,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/casgn_node.rb

@@ -3,7 +3,7 @@
 module Rucoa
   module Nodes
     class CasgnNode < Base
-      include NodeConcerns::NameFullQualifiable
+      include NodeConcerns::NameFullyQualifiable
 
       # @return [String]
       def name

data/lib/rucoa/nodes/cbase_node.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Nodes
+    class CbaseNode < Base
+    end
+  end
+end

data/lib/rucoa/nodes/class_node.rb

@@ -2,7 +2,68 @@
 
 module Rucoa
   module Nodes
-    class ClassNode < ModuleNode
+    class ClassNode < Base
+      include NodeConcerns::NameFullyQualifiable
+
+      # @return [String]
+      def name
+        const_node.name
+      end
+
+      # @return [String, nil]
+      # @example returns nil for class for `class Foo`
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY,
+      #       class Foo
+      #       end
+      #     RUBY
+      #     uri: 'file:///path/to/foo.rb'
+      #   ).root_node
+      #   expect(node.super_class_chained_name).to be_nil
+      # @example returns "Bar" for class for `class Foo < Bar`
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY,
+      #       class Foo < Bar
+      #       end
+      #     RUBY
+      #     uri: 'file:///path/to/foo.rb'
+      #   ).root_node
+      #   expect(node.super_class_chained_name).to eq('Bar')
+      # @example returns "Bar::Baz" for class for `class Foo < Bar::Baz`
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY,
+      #       class Foo < Bar::Baz
+      #       end
+      #     RUBY
+      #     uri: 'file:///path/to/foo.rb'
+      #   ).root_node
+      #   expect(node.super_class_chained_name).to eq('Bar::Baz')
+      # @example returns "::Bar" for class for `class Foo < ::Bar`
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY,
+      #       class Foo < ::Bar
+      #       end
+      #     RUBY
+      #     uri: 'file:///path/to/foo.rb'
+      #   ).root_node
+      #   expect(node.super_class_chained_name).to eq('::Bar')
+      def super_class_chained_name
+        return unless super_class_node.is_a?(Nodes::ConstNode)
+
+        super_class_node.chained_name
+      end
+
+      private
+
+      # @return [Rucoa::Nodes::ConstNode]
+      def const_node
+        children[0]
+      end
+
+      # @return [Rucoa::Nodes::Base, nil]
+      def super_class_node
+        children[1]
+      end
     end
   end
 end

data/lib/rucoa/nodes/const_node.rb

@@ -4,9 +4,81 @@ module Rucoa
   module Nodes
     class ConstNode < Base
       # @return [String]
+      # @example returns "A" for "A"
+      #   node = Rucoa::Parser.call(
+      #     path: '/path/to/example.rb',
+      #     text: 'A'
+      #   ).root_node
+      #   expect(node.name).to eq('A')
+      # @example returns "B" for "A::B"
+      #   node = Rucoa::Parser.call(
+      #     path: '/path/to/example.rb',
+      #     text: 'A::B'
+      #   ).root_node
+      #   expect(node.name).to eq('B')
       def name
         children[1].to_s
       end
+
+      # @return [String]
+      # @example returns "A" for "A"
+      #   node = Rucoa::Parser.call(
+      #     path: '/path/to/example.rb',
+      #     text: 'A'
+      #   ).root_node
+      #   expect(node.chained_name).to eq('A')
+      # @example returns "A::B" for "A::B"
+      #   node = Rucoa::Parser.call(
+      #     path: '/path/to/example.rb',
+      #     text: 'A::B'
+      #   ).root_node
+      #   expect(node.chained_name).to eq('A::B')
+      def chained_name
+        case receiver
+        when Nodes::CbaseNode
+          [
+            '',
+            name
+          ].join('::')
+        when Nodes::ConstNode
+          [
+            receiver.chained_name,
+            name
+          ].join('::')
+        else
+          name
+        end
+      end
+
+      # @return [Array<String>]
+      # @example return ["Bar::Foo", "Foo"] for class Foo::Bar::Baz
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY,
+      #       module Foo
+      #         module Bar
+      #           module Baz
+      #           end
+      #         end
+      #       end
+      #     RUBY
+      #     uri: 'file:///path/to/foo/bar/baz.rb'
+      #   ).node_at(
+      #     Rucoa::Position.new(
+      #       column: 4,
+      #       line: 3
+      #     )
+      #   )
+      #   expect(node.module_nesting).to eq(['Foo::Bar', 'Foo'])
+      def module_nesting
+        each_ancestor(:class, :module).map(&:fully_qualified_name)
+      end
+
+      private
+
+      # @return [Rucoa::Nodes::Base, nil]
+      def receiver
+        children[0]
+      end
     end
   end
 end

data/lib/rucoa/nodes/def_node.rb

@@ -6,7 +6,7 @@ module Rucoa
       # @return [String]
       # @example returns method name
       #   node = Rucoa::Source.new(
-      #     content: <<~RUBY
+      #     content: <<~RUBY,
       #       module Foo
       #         class Bar
       #           def baz
@@ -14,6 +14,7 @@ module Rucoa
       #         end
       #       end
       #     RUBY
+      #     uri: 'file:///path/to/foo/bar.rb'
       #   ).node_at(
       #     Rucoa::Position.new(
       #       column: 4,
@@ -28,7 +29,7 @@ module Rucoa
       # @return [String]
       # @example returns full qualified name
       #   node = Rucoa::Source.new(
-      #     content: <<~RUBY
+      #     content: <<~RUBY,
       #       module Foo
       #         class Bar
       #           def baz
@@ -36,14 +37,15 @@ module Rucoa
       #         end
       #       end
       #     RUBY
+      #     uri: 'file:///path/to/foo/bar.rb'
       #   ).node_at(
       #     Rucoa::Position.new(
       #       column: 4,
       #       line: 3
       #     )
       #   )
-      #   expect(node.full_qualified_name).to eq('Foo::Bar#baz')
-      def full_qualified_name
+      #   expect(node.fully_qualified_name).to eq('Foo::Bar#baz')
+      def fully_qualified_name
         [
           namespace,
           method_marker,
@@ -51,6 +53,11 @@ module Rucoa
         ].join
       end
 
+      # @return [Boolean]
+      def singleton?
+        each_ancestor(:sclass).any?
+      end
+
       private
 
       # @return [String]
@@ -61,11 +68,6 @@ module Rucoa
           '#'
         end
       end
-
-      # @return [Boolean]
-      def singleton?
-        each_ancestor(:sclass).any?
-      end
     end
   end
 end

data/lib/rucoa/nodes/defs_node.rb

@@ -3,10 +3,31 @@
 module Rucoa
   module Nodes
     class DefsNode < Base
+      # @return [String]
+      def fully_qualified_name
+        [
+          namespace,
+          method_marker,
+          name
+        ].join
+      end
+
       # @return [String]
       def name
         children[1].to_s
       end
+
+      # @return [Boolean]
+      def singleton?
+        true
+      end
+
+      private
+
+      # @return [String]
+      def method_marker
+        '.'
+      end
     end
   end
 end