rucoa 0.9.0 → 0.10.0

data/lib/rucoa/node_inspector.rb

@@ -4,7 +4,10 @@ module Rucoa
   class NodeInspector
     # @param definition_store [Rucoa::DefinitionStore]
     # @param node [Rucoa::Node]
-    def initialize(definition_store:, node:)
+    def initialize(
+      definition_store:,
+      node:
+    )
       @definition_store = definition_store
       @node = node
     end
@@ -90,22 +93,14 @@ module Rucoa
     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|
-        [
-          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
+      @definition_store.find_definition_by_qualified_name(
+        @definition_store.resolve_constant(
+          UnqualifiedName.new(
+            chained_name: @node.chained_name,
+            module_nesting: @node.module_nesting
+          )
+        )
+      )
     end
 
     # @return [Boolean]
@@ -114,16 +109,16 @@ module Rucoa
     end
 
     # @return [String, nil]
-    def nearest_def_fully_qualified_name
-      @node.each_ancestor(:def).first&.fully_qualified_name
+    def nearest_def_qualified_name
+      @node.each_ancestor(:def).first&.qualified_name
     end
 
     # @return [Array<String>]
     def return_types_for_lvar
-      fully_qualified_name = nearest_def_fully_qualified_name
-      return [] unless fully_qualified_name
+      qualified_name = nearest_def_qualified_name
+      return [] unless qualified_name
 
-      definition = @definition_store.find_definition_by_fully_qualified_name(fully_qualified_name)
+      definition = @definition_store.find_definition_by_qualified_name(qualified_name)
       return [] unless definition
 
       definition.parameters.select do |parameter|

data/lib/rucoa/nodes/base.rb

@@ -37,7 +37,10 @@ module Rucoa
       # @param types [Array<Symbol>]
       # @return [Rucoa::Nodes::Base] if a block is given
       # @return [Enumerator] if no block is given
-      def each_ancestor(*types, &block)
+      def each_ancestor(
+        *types,
+        &block
+      )
         return to_enum(__method__, *types) unless block
 
         visit_ancestors(types, &block)
@@ -47,7 +50,10 @@ module Rucoa
       # @param types [Array<Symbol>]
       # @return [Rucoa::Nodes::Base] if a block is given
       # @return [Enumerator] if no block is given
-      def each_child_node(*types, &block)
+      def each_child_node(
+        *types,
+        &block
+      )
         return to_enum(__method__, *types) unless block
 
         visit_child_node(types, &block)
@@ -57,7 +63,10 @@ module Rucoa
       # @param types [Array<Symbol>]
       # @return [Rucoa::Nodes::Base] if a block is given
       # @return [Enumerator] if no block is given
-      def each_descendant(*types, &block)
+      def each_descendant(
+        *types,
+        &block
+      )
         return to_enum(__method__, *types) unless block
 
         visit_descendants(types, &block)
@@ -68,7 +77,11 @@ module Rucoa
       #   Some nodes change their type depending on the context.
       #   For example, `const` node can be `casgn` node.
       # @return [Rucoa::Nodes::Base]
-      def updated(type = nil, children = nil, properties = {})
+      def updated(
+        type = nil,
+        children = nil,
+        properties = {}
+      )
         properties[:location] ||= @location
         ParserBuilder.node_class_for(type || @type).new(
           type || @type,
@@ -137,7 +150,7 @@ module Rucoa
       #   )
       #   expect(node.module_nesting).to eq(['Foo::Bar', 'Foo'])
       def module_nesting
-        each_ancestor(:class, :module).map(&:fully_qualified_name)
+        each_ancestor(:class, :module).map(&:qualified_name)
       end
 
       protected
@@ -145,7 +158,10 @@ module Rucoa
       # Visit all descendants.
       # @param types [Array<Symbol>]
       # @return [void]
-      def visit_descendants(types, &block)
+      def visit_descendants(
+        types,
+        &block
+      )
         each_child_node do |child|
           yield(child) if types.empty? || types.include?(child.type)
           child.visit_descendants(types, &block)

data/lib/rucoa/nodes/begin_node.rb

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

data/lib/rucoa/nodes/casgn_node.rb

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

data/lib/rucoa/nodes/class_node.rb

@@ -3,7 +3,8 @@
 module Rucoa
   module Nodes
     class ClassNode < Base
-      include NodeConcerns::NameFullyQualifiable
+      include NodeConcerns::Body
+      include NodeConcerns::QualifiedName
 
       # @return [String]
       def name

data/lib/rucoa/nodes/const_node.rb

@@ -5,16 +5,25 @@ module Rucoa
     class ConstNode < Base
       # @return [String]
       # @example returns "A" for "A"
-      #   node = Rucoa::Parser.call(
-      #     path: '/path/to/example.rb',
-      #     text: 'A'
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY,
+      #       A
+      #     RUBY
+      #     uri: 'file:///path/to/a.rb'
       #   ).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
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY,
+      #       A::B
+      #     RUBY
+      #     uri: 'file:///path/to/a.rb'
+      #   ).node_at(
+      #     Rucoa::Position.new(
+      #       column: 4,
+      #       line: 1
+      #     )
+      #   )
       #   expect(node.name).to eq('B')
       def name
         children[1].to_s
@@ -22,16 +31,25 @@ module Rucoa
 
       # @return [String]
       # @example returns "A" for "A"
-      #   node = Rucoa::Parser.call(
-      #     path: '/path/to/example.rb',
-      #     text: 'A'
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY,
+      #       A
+      #     RUBY
+      #     uri: 'file:///path/to/a.rb'
       #   ).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
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY,
+      #       A::B
+      #     RUBY
+      #     uri: 'file:///path/to/a.rb'
+      #   ).node_at(
+      #     Rucoa::Position.new(
+      #       column: 4,
+      #       line: 1
+      #     )
+      #   )
       #   expect(node.chained_name).to eq('A::B')
       def chained_name
         case receiver
@@ -70,7 +88,7 @@ module Rucoa
       #   )
       #   expect(node.module_nesting).to eq(['Foo::Bar', 'Foo'])
       def module_nesting
-        each_ancestor(:class, :module).map(&:fully_qualified_name)
+        each_ancestor(:class, :module).map(&:qualified_name)
       end
 
       private

data/lib/rucoa/nodes/def_node.rb

@@ -44,8 +44,8 @@ module Rucoa
       #       line: 3
       #     )
       #   )
-      #   expect(node.fully_qualified_name).to eq('Foo::Bar#baz')
-      def fully_qualified_name
+      #   expect(node.qualified_name).to eq('Foo::Bar#baz')
+      def qualified_name
         [
           namespace,
           method_marker,

data/lib/rucoa/nodes/defs_node.rb

@@ -4,7 +4,7 @@ module Rucoa
   module Nodes
     class DefsNode < Base
       # @return [String]
-      def fully_qualified_name
+      def qualified_name
         [
           namespace,
           method_marker,

data/lib/rucoa/nodes/module_node.rb

@@ -3,7 +3,8 @@
 module Rucoa
   module Nodes
     class ModuleNode < Base
-      include NodeConcerns::NameFullyQualifiable
+      include NodeConcerns::Body
+      include NodeConcerns::QualifiedName
 
       # @return [String]
       def name

data/lib/rucoa/nodes.rb

@@ -3,9 +3,10 @@
 module Rucoa
   module Nodes
     autoload :Base, 'rucoa/nodes/base'
+    autoload :BeginNode, 'rucoa/nodes/begin_node'
+    autoload :CasgnNode, 'rucoa/nodes/casgn_node'
     autoload :CbaseNode, 'rucoa/nodes/cbase_node'
     autoload :ClassNode, 'rucoa/nodes/class_node'
-    autoload :CasgnNode, 'rucoa/nodes/casgn_node'
     autoload :ConstNode, 'rucoa/nodes/const_node'
     autoload :DefNode, 'rucoa/nodes/def_node'
     autoload :DefsNode, 'rucoa/nodes/defs_node'

data/lib/rucoa/parser.rb

@@ -5,47 +5,47 @@ require 'parser/current'
 module Rucoa
   class Parser
     class << self
-      # @param path [String]
       # @param text [String]
+      # @param uri [String]
       # @return [Rucoa::ParseResult]
       # @example returns non-failed parse result for valid Ruby source
       #   result = Rucoa::Parser.call(
-      #     path: '/path/to/foo.rb',
-      #     text: 'foo'
+      #     text: 'foo',
+      #     uri: 'file:///path/to/foo.rb'
       #   )
       #   expect(result).not_to be_failed
       # @example returns failed parse result for invalid Ruby source
       #   result = Rucoa::Parser.call(
-      #     path: '/path/to/foo.rb',
-      #     text: 'foo('
+      #     text: 'foo(',
+      #     uri: 'file:///path/to/foo.rb'
       #   )
       #   expect(result).to be_failed
       def call(
-        path:,
-        text:
+        text:,
+        uri:
       )
         new(
-          path: path,
-          text: text
+          text: text,
+          uri: uri
         ).call
       end
     end
 
-    # @param path [String]
     # @param text [String]
+    # @param uri [String]
     def initialize(
-      path:,
-      text:
+      text:,
+      uri:
     )
-      @path = path
       @text = text
+      @uri = uri
     end
 
     # @return [Rucoa::ParseResult]
     def call
       root_node, comments = parser.parse_with_comments(
         ::Parser::Source::Buffer.new(
-          @path,
+          @uri,
           source: @text
         )
       )

data/lib/rucoa/parser_builder.rb

@@ -5,6 +5,7 @@ require 'parser/current'
 module Rucoa
   class ParserBuilder < ::Parser::Builders::Default
     NODE_CLASS_BY_TYPE = {
+      begin: Nodes::BeginNode,
       casgn: Nodes::CasgnNode,
       cbase: Nodes::CbaseNode,
       class: Nodes::ClassNode,
@@ -28,7 +29,11 @@ module Rucoa
     end
 
     # @note Override.
-    def n(type, children, source_map)
+    def n(
+      type,
+      children,
+      source_map
+    )
       self.class.node_class_for(type).new(
         type,
         children,

data/lib/rucoa/position.rb

@@ -39,11 +39,20 @@ module Rucoa
 
     # @param column [Integer] 0-origin column number
     # @param line [Integer] 1-origin line number
-    def initialize(column: 0, line: 1)
+    def initialize(
+      column: 0,
+      line: 1
+    )
       @column = column
       @line = line
     end
 
+    # @param other [Rucoa::Position]
+    # @return [Boolean]
+    def ==(other)
+      column == other.column && line == other.line
+    end
+
     # @param text [String]
     # @return [Integer]
     def to_index_of(text)

data/lib/rucoa/range.rb

@@ -31,12 +31,22 @@ module Rucoa
     # @param beginning [Rucoa::Position]
     # @param ending [Ruoca::Position]
     # @param including_ending [Boolean]
-    def initialize(beginning, ending, including_ending: true)
+    def initialize(
+      beginning,
+      ending,
+      including_ending: true
+    )
       @beginning = beginning
       @ending = ending
       @including_ending = including_ending
     end
 
+    # @param other [Rucoa::Range]
+    # @return [Boolean]
+    def ==(other)
+      beginning == other.beginning && ending == other.ending
+    end
+
     # @param range [Rucoa::Range]
     # @return [Boolean]
     # @example returns true when the range is contained in self

data/lib/rucoa/rbs/class_definition_mapper.rb

@@ -2,43 +2,28 @@
 
 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
-
+    class ClassDefinitionMapper < ModuleDefinitionMapper
       # @return [Rucoa::Definitions::ClassDefinition]
+      # @example supports `include`
+      #   definition_store = Rucoa::DefinitionStore.new
+      #   definition_store.bulk_add(Rucoa::DefinitionArchiver.load)
+      #   subject = definition_store.find_definition_by_qualified_name('Array')
+      #   expect(subject.included_module_qualified_names).to include('Enumerable')
       def call
         Definitions::ClassDefinition.new(
-          fully_qualified_name: fully_qualified_name,
-          source_path: source_path,
-          super_class_fully_qualified_name: super_class_fully_qualified_name
+          description: description,
+          included_module_qualified_names: included_module_qualified_names,
+          location: location,
+          prepended_module_qualified_names: prepended_module_qualified_names,
+          qualified_name: qualified_name,
+          super_class_qualified_name: super_class_qualified_name
         )
       end
 
       private
 
-      # @return [String]
-      def fully_qualified_name
-        @declaration.name.to_s.delete_prefix('::')
-      end
-
-      # @return [String]
-      def source_path
-        @declaration.location.name
-      end
-
       # @return [String, nil]
-      def super_class_fully_qualified_name
+      def super_class_qualified_name
         @declaration.super_class&.name&.to_s&.delete_prefix('::')
       end
     end

data/lib/rucoa/rbs/constant_definition_mapper.rb

@@ -19,21 +19,27 @@ module Rucoa
       # @return [Rucoa::Definitions::ConstantDefinition]
       def call
         Definitions::ConstantDefinition.new(
-          fully_qualified_name: fully_qualified_name,
-          source_path: source_path
+          description: description,
+          location: location,
+          qualified_name: qualified_name
         )
       end
 
       private
 
+      # @return [String, nil]
+      def description
+        @declaration.comment&.string&.sub(/\A\s*<!--.*-->\s*/m, '')
+      end
+
       # @return [String]
-      def fully_qualified_name
+      def qualified_name
         @declaration.name.to_s.delete_prefix('::')
       end
 
-      # @return [String]
-      def source_path
-        @declaration.location.name
+      # @return [Rucoa::Location]
+      def location
+        Location.from_rbs_location(@declaration.location)
       end
     end
   end

data/lib/rucoa/rbs/method_definition_mapper.rb

@@ -7,7 +7,10 @@ module Rucoa
         # @param declaration [RBS::AST::Declarations::Class, RBS::AST::Declarations::Module]
         # @param method_definition [RBS::AST::Members::MethodDefinition]
         # @return [Rucoa::Definitions::MethodDefinition]
-        def call(declaration:, method_definition:)
+        def call(
+          declaration:,
+          method_definition:
+        )
           new(
             declaration: declaration,
             method_definition: method_definition
@@ -17,7 +20,10 @@ module Rucoa
 
       # @param declaration [RBS::AST::Declarations::Class, RBS::AST::Declarations::Module]
       # @param method_definition [RBS::AST::Members::MethodDefinition]
-      def initialize(declaration:, method_definition:)
+      def initialize(
+        declaration:,
+        method_definition:
+      )
         @declaration = declaration
         @method_definition = method_definition
       end
@@ -27,9 +33,9 @@ module Rucoa
         Definitions::MethodDefinition.new(
           description: description,
           kind: kind,
+          location: location,
           method_name: method_name,
           namespace: namespace,
-          source_path: source_path,
           types: types
         )
       end
@@ -65,9 +71,9 @@ module Rucoa
         @method_definition.kind
       end
 
-      # @return [String]
-      def source_path
-        @declaration.location.name
+      # @return [Rucoa::Location]
+      def location
+        Location.from_rbs_location(@method_definition.location)
       end
 
       class MethodTypeMapper

data/lib/rucoa/rbs/module_definition_mapper.rb

@@ -19,21 +19,49 @@ module Rucoa
       # @return [Rucoa::Definitions::ModuleDefinition]
       def call
         Definitions::ModuleDefinition.new(
-          fully_qualified_name: fully_qualified_name,
-          source_path: source_path
+          description: description,
+          included_module_qualified_names: included_module_qualified_names,
+          location: location,
+          prepended_module_qualified_names: prepended_module_qualified_names,
+          qualified_name: qualified_name
         )
       end
 
       private
 
+      # @return [String, nil]
+      def description
+        @declaration.comment&.string&.sub(/\A\s*<!--.*-->\s*/m, '')
+      end
+
       # @return [String]
-      def fully_qualified_name
+      def qualified_name
         @declaration.name.to_s.delete_prefix('::')
       end
 
-      # @return [String]
-      def source_path
-        @declaration.location.name
+      # @return [Rucoa::Location]
+      def location
+        Location.from_rbs_location(@declaration.location)
+      end
+
+      # @return [Array<String>]
+      def included_module_qualified_names
+        @declaration.members.filter_map do |member|
+          case member
+          when ::RBS::AST::Members::Include
+            member.name.to_s.delete_prefix('::')
+          end
+        end
+      end
+
+      # @return [Array<String>]
+      def prepended_module_qualified_names
+        @declaration.members.filter_map do |member|
+          case member
+          when ::RBS::AST::Members::Prepend
+            member.name.to_s.delete_prefix('::')
+          end
+        end
       end
     end
   end

data/lib/rucoa/rubocop/investigator.rb

@@ -41,7 +41,10 @@ module Rucoa
       # @param file [String]
       # @param offenses [Array<RuboCop::Cop::Offense>]
       # @return [void]
-      def file_finished(file, offenses)
+      def file_finished(
+        file,
+        offenses
+      )
         @offenses = offenses
         super
       end

data/lib/rucoa/server.rb

@@ -83,7 +83,10 @@ module Rucoa
     # @yieldparam response [Hash]
     # @param message [Hash]
     # @return [void]
-    def write(message, &block)
+    def write(
+      message,
+      &block
+    )
       if block
         write_server_request(message, &block)
       else
@@ -139,7 +142,10 @@ module Rucoa
 
     # @param message [Hash]
     # @return [void]
-    def write_server_request(message, &block)
+    def write_server_request(
+      message,
+      &block
+    )
       message = message.merge('id' => @server_request_id)
       debug do
         {