rucoa 0.9.0 → 0.10.0

data/lib/rucoa/definitions/constant_definition.rb

@@ -5,25 +5,30 @@ module Rucoa
     # Represents class definition, module definition, or constant assignment.
     class ConstantDefinition < Base
       # @return [String]
-      attr_reader :fully_qualified_name
+      attr_reader :qualified_name
 
-      # @return [String]
-      attr_reader :source_path
-
-      # @param fully_qualified_name [String]
-      # @param source_path [String]
-      def initialize(fully_qualified_name:, source_path:)
-        super()
-        @fully_qualified_name = fully_qualified_name
-        @source_path = source_path
+      # @param qualified_name [String]
+      def initialize(
+        qualified_name:,
+        **keyword_arguments
+      )
+        super(**keyword_arguments)
+        @qualified_name = qualified_name
       end
 
       # @return [String]
       # @example returns non-full-qualified name
-      #   definition = Rucoa::Definitions::ConstantDefinition.new(
-      #     fully_qualified_name: 'Foo::Bar::Baz',
-      #     source_path: '/path/to/foo/bar/baz.rb'
-      #   )
+      #   definition = Rucoa::Source.new(
+      #     content: <<~RUBY,
+      #       module Foo
+      #         module Bar
+      #           class Baz
+      #           end
+      #         end
+      #       end
+      #     RUBY
+      #     uri: 'file:///path/to/foo/bar/baz.rb',
+      #   ).definitions[2]
       #   expect(definition.name).to eq('Baz')
       def name
         names.last
@@ -31,10 +36,17 @@ module Rucoa
 
       # @return [String]
       # @example returns namespace
-      #   definition = Rucoa::Definitions::ConstantDefinition.new(
-      #     fully_qualified_name: 'Foo::Bar::Baz',
-      #     source_path: '/path/to/foo/bar/baz.rb'
-      #   )
+      #   definition = Rucoa::Source.new(
+      #     content: <<~RUBY,
+      #       module Foo
+      #         module Bar
+      #           class Baz
+      #           end
+      #         end
+      #       end
+      #     RUBY
+      #     uri: 'file:///path/to/foo/bar/baz.rb',
+      #   ).definitions[2]
       #   expect(definition.namespace).to eq('Foo::Bar')
       def namespace
         names[..-2].join('::')
@@ -44,7 +56,7 @@ module Rucoa
 
       # @return [Array<String>]
       def names
-        @names ||= fully_qualified_name.split('::')
+        @names ||= qualified_name.split('::')
       end
     end
   end

data/lib/rucoa/definitions/method_definition.rb

@@ -3,9 +3,6 @@
 module Rucoa
   module Definitions
     class MethodDefinition < Base
-      # @return [String, nil]
-      attr_reader :description
-
       # @return [Symbol]
       attr_reader :kind
 
@@ -15,44 +12,39 @@ module Rucoa
       # @return [String]
       attr_reader :namespace
 
-      # @return [String]
-      attr_reader :source_path
-
-      # @param description [String, nil]
       # @param kind [Symbol]
       # @param method_name [String]
       # @param namespace [String]
-      # @param source_path [String]
       # @param types [Array<Rucoa::Types::MethodType>]
       def initialize(
-        description:,
         kind:,
         method_name:,
         namespace:,
-        source_path:,
-        types:
+        types:,
+        **keyword_arguments
       )
-        super()
-        @description = description
+        super(**keyword_arguments)
         @kind = kind
         @method_name = method_name
         @namespace = namespace
-        @source_path = source_path
         @types = types
       end
 
       # @return [String]
       # @example returns qualified name of method
-      #   method_definition = Rucoa::Definitions::MethodDefinition.new(
-      #     description: nil,
-      #     kind: :instance,
-      #     method_name: 'foo',
-      #     namespace: 'Foo::Bar',
-      #     source_path: '/path/to/foo/bar.rb',
-      #     types: []
-      #   )
-      #   expect(method_definition.fully_qualified_name).to eq('Foo::Bar#foo')
-      def fully_qualified_name
+      #   definition = Rucoa::Source.new(
+      #     content: <<~RUBY,
+      #       module Foo
+      #         module Bar
+      #           def foo
+      #           end
+      #         end
+      #       end
+      #     RUBY
+      #     uri: 'file:///path/to/foo/bar/baz.rb',
+      #   ).definitions[2]
+      #   expect(definition.qualified_name).to eq('Foo::Bar#foo')
+      def qualified_name
         [
           @namespace,
           method_kind_symbol,
@@ -68,46 +60,46 @@ module Rucoa
 
       # @return [Array<String>]
       # @example returns return types
-      #   method_definition = Rucoa::Definitions::MethodDefinition.new(
-      #     description: nil,
-      #     kind: :instance,
-      #     method_name: 'foo',
-      #     namespace: 'Foo::Bar',
-      #     source_path: '/path/to/foo/bar.rb',
-      #     types: [
-      #       Rucoa::Types::MethodType.new(
-      #         parameters_string: '',
-      #         return_type: 'String'
-      #       )
-      #     ]
-      #   )
-      #   expect(method_definition.return_types).to eq(%w[String])
+      #   definition = Rucoa::Source.new(
+      #     content: <<~RUBY,
+      #       module Foo
+      #         module Bar
+      #           # @return [String]
+      #           def baz
+      #           end
+      #         end
+      #       end
+      #     RUBY
+      #     uri: 'file:///path/to/foo/bar.rb',
+      #   ).definitions[2]
+      #   expect(definition.return_types).to eq(%w[String])
       def return_types
         @types.map(&:return_type)
       end
 
       # @return [Array<String>]
       # @example returns signature
-      #   method_definition = Rucoa::Definitions::MethodDefinition.new(
-      #     description: nil,
-      #     kind: :instance,
-      #     method_name: 'foo',
-      #     namespace: 'Foo::Bar',
-      #     source_path: '/path/to/foo/bar.rb',
-      #     types: [
-      #       Rucoa::Types::MethodType.new(
-      #         parameters_string: '?::int base',
-      #         return_type: 'String'
-      #       )
+      #   definition = Rucoa::Source.new(
+      #     content: <<~RUBY,
+      #       module Foo
+      #         module Bar
+      #           attr_writer :baz
+      #         end
+      #       end
+      #     RUBY
+      #     uri: 'file:///path/to/foo/bar.rb',
+      #   ).definitions[2]
+      #   expect(definition.signatures).to eq(
+      #     [
+      #       'Foo::Bar#baz=(value) -> Object'
       #     ]
       #   )
-      #   expect(method_definition.signatures).to eq(['Foo::Bar#foo(?::int base) -> String'])
       def signatures
         @types.map do |type|
           format(
-            '%<fully_qualified_name>s(%<parameters>s) -> %<return_types>s',
-            fully_qualified_name: fully_qualified_name,
+            '%<qualified_name>s(%<parameters>s) -> %<return_types>s',
             parameters: type.parameters_string,
+            qualified_name: qualified_name,
             return_types: type.return_type
           )
         end

data/lib/rucoa/definitions/method_parameter_definition.rb

@@ -12,7 +12,10 @@ module Rucoa
 
       # @param name [String]
       # @param types [Array<String>]
-      def initialize(name:, types:)
+      def initialize(
+        name:,
+        types:
+      )
         super()
         @name = name
         @types = types

data/lib/rucoa/definitions/module_definition.rb

@@ -3,6 +3,45 @@
 module Rucoa
   module Definitions
     class ModuleDefinition < ConstantDefinition
+      # @return [Array<String>]
+      attr_accessor :included_module_qualified_names
+
+      # @return [Array<Rucoa::UnqualifiedName>]
+      attr_accessor :included_module_unqualified_names
+
+      # @return [Array<String>]
+      attr_accessor :prepended_module_qualified_names
+
+      # @return [Array<Rucoa::UnqualifiedName>]
+      attr_accessor :prepended_module_unqualified_names
+
+      # @param included_module_qualified_names [Array<String>]
+      # @param included_module_unqualified_names [Array<String>]
+      # @param prepended_module_qualified_names [Array<String>]
+      # @param prepended_module_unqualified_names [Array<String>]
+      def initialize(
+        included_module_qualified_names: [],
+        included_module_unqualified_names: [],
+        prepended_module_qualified_names: [],
+        prepended_module_unqualified_names: [],
+        **keyword_arguments
+      )
+        super(**keyword_arguments)
+        @included_module_qualified_names = included_module_qualified_names
+        @included_module_unqualified_names = included_module_unqualified_names
+        @prepended_module_qualified_names = prepended_module_qualified_names
+        @prepended_module_unqualified_names = prepended_module_unqualified_names
+      end
+
+      # @param other [Rucoa::Definitions::ModuleDefinition]
+      # @return [Rucoa::Definitions::ModuleDefinition]
+      def merge!(other)
+        self.included_module_qualified_names |= other.included_module_qualified_names
+        self.included_module_unqualified_names |= other.included_module_unqualified_names
+        self.prepended_module_qualified_names |= other.prepended_module_qualified_names
+        self.prepended_module_unqualified_names |= other.prepended_module_unqualified_names
+        self
+      end
     end
   end
 end

data/lib/rucoa/handler_concerns/diagnostics_publishable.rb

@@ -53,7 +53,10 @@ module Rucoa
 
         # @param source [Rucoa::Source]
         # @param uri [String]
-        def initialize(source:, uri:)
+        def initialize(
+          source:,
+          uri:
+        )
           @source = source
           @uri = uri
         end
@@ -102,7 +105,11 @@ module Rucoa
             # @param source [Rucoa::Source]
             # @param uri [String]
             # @return [Hash]
-            def call(offense, source:, uri:)
+            def call(
+              offense,
+              source:,
+              uri:
+            )
               new(
                 offense,
                 source: source,
@@ -114,7 +121,11 @@ module Rucoa
           # @param offense [RuboCop::Cop::Offense]
           # @param source [Rucoa::Source]
           # @param uri [String]
-          def initialize(offense, source:, uri:)
+          def initialize(
+            offense,
+            source:,
+            uri:
+          )
             @offense = offense
             @source = source
             @uri = uri

data/lib/rucoa/handlers/base.rb

@@ -7,7 +7,10 @@ module Rucoa
         # @param server [Rucoa::Server]
         # @param request [Hash]
         # @return [void]
-        def call(request:, server:)
+        def call(
+          request:,
+          server:
+        )
           new(
             request: request,
             server: server
@@ -17,7 +20,10 @@ module Rucoa
 
       # @param request [Hash]
       # @param server [Rucoa::Server]
-      def initialize(request:, server:)
+      def initialize(
+        request:,
+        server:
+      )
         @request = request
         @server = server
       end
@@ -61,7 +67,10 @@ module Rucoa
 
       # @param message [Hash]
       # @return [void]
-      def write(message, &block)
+      def write(
+        message,
+        &block
+      )
         @server.write(message, &block)
       end
     end

data/lib/rucoa/handlers/text_document_definition_handler.rb

@@ -14,52 +14,15 @@ module Rucoa
         return unless reponsible?
 
         {
-          range: location_range.to_vscode_range,
-          uri: location_uri
+          range: definition.location.range.to_vscode_range,
+          uri: definition.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)
+          !definition&.location.nil?
       end
 
       # @return [Rucoa::Position]
@@ -91,65 +54,6 @@ module Rucoa
           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_hover_handler.rb

@@ -22,18 +22,24 @@ module Rucoa
       # @return [Boolean]
       def responsible?
         configuration.enables_hover? &&
-          !source.nil? &&
-          !node.nil? &&
-          !method_definitions.empty?
+          !contents.nil?
       end
 
       # @return [String, nil]
       def contents
-        method_definition = method_definitions.first
-        [
-          method_definition.signatures.join("\n"),
-          method_definition.description
-        ].join("\n\n")
+        @contents ||=
+          case definition
+          when Definitions::ClassDefinition, Definitions::ConstantDefinition, Definitions::ModuleDefinition
+            [
+              definition.qualified_name,
+              definition.description
+            ].compact.join("\n")
+          when Definitions::MethodDefinition
+            [
+              definition.signatures.join("\n"),
+              definition.description
+            ].join("\n\n")
+          end
       end
 
       # @return [Rucoa::Range]
@@ -43,7 +49,7 @@ module Rucoa
 
       # @return [Rucoa::Nodes::Base, nil]
       def node
-        @node ||= source.node_at(position)
+        @node ||= source&.node_at(position)
       end
 
       # @return [Rucoa::Source, nil]
@@ -63,12 +69,14 @@ module Rucoa
         )
       end
 
-      # @return [Array<Rucoa::Definitions::MethodDefinition>]
-      def method_definitions
-        @method_definitions ||= NodeInspector.new(
+      # @return [Rucoa::Definitions::Base, nil]
+      def definition
+        return unless node
+
+        @definition ||= NodeInspector.new(
           definition_store: definition_store,
           node: node
-        ).method_definitions
+        ).definitions.first
       end
     end
   end

data/lib/rucoa/handlers/text_document_selection_range_handler.rb

@@ -46,7 +46,10 @@ module Rucoa
           # @param source [Rucoa::Source]
           # @param position [Rucoa::Position]
           # @return [Hash, nil]
-          def call(position:, source:)
+          def call(
+            position:,
+            source:
+          )
             new(
               position: position,
               source: source
@@ -56,7 +59,10 @@ module Rucoa
 
         # @param position [Rucoa::Position]
         # @param source [Rucoa::Source]
-        def initialize(position:, source:)
+        def initialize(
+          position:,
+          source:
+        )
           @position = position
           @source = source
         end

data/lib/rucoa/location.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Rucoa
+  Location = ::Struct.new(
+    :range,
+    :uri,
+    keyword_init: true
+  ) do
+    class << self
+      # @param location [RBS::Location]
+      # @return [Rucoa::Location]
+      def from_rbs_location(location)
+        new(
+          range: Range.new(
+            Position.new(
+              column: location.start_column,
+              line: location.start_line
+            ),
+            Position.new(
+              column: location.end_column,
+              line: location.end_line
+            )
+          ),
+          uri: "file://#{location.name}"
+        )
+      end
+
+      # @param node [Rucoa::Nodes::Base]
+      def from_rucoa_node(node)
+        new(
+          range: Range.from_parser_range(node.location.expression),
+          uri: node.location.expression.source_buffer.name
+        )
+      end
+    end
+  end
+end

data/lib/rucoa/node_concerns/body.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module NodeConcerns
+    module Body
+      # @return [Rucoa::Nodes::BeginNode, nil]
+      def body
+        children[2]
+      end
+
+      # @return [Array<Rucoa::Nodes::Base>]
+      def body_children
+        case body
+        when Nodes::BeginNode
+          body.children
+        when nil
+          []
+        else
+          [body]
+        end
+      end
+    end
+  end
+end

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

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

data/lib/rucoa/node_concerns.rb

@@ -2,6 +2,7 @@
 
 module Rucoa
   module NodeConcerns
-    autoload :NameFullyQualifiable, 'rucoa/node_concerns/name_fully_qualifiable'
+    autoload :Body, 'rucoa/node_concerns/body'
+    autoload :QualifiedName, 'rucoa/node_concerns/qualified_name'
   end
 end