rucoa 0.9.0 → 0.11.0

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

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
@@ -48,7 +51,7 @@ module Rucoa
     def return_types
       case @node.type
       when :const
-        ["singleton<#{@node.name}>"]
+        return_types_for_const
       when :lvar
         return_types_for_lvar
       when :send
@@ -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,27 @@ 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_const
+      qualified_name = @definition_store.resolve_constant(
+        UnqualifiedName.new(
+          chained_name: @node.chained_name,
+          module_nesting: @node.module_nesting
+        )
+      )
+      ["singleton<#{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,29 @@
 
 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,
+          extended_module_qualified_names: extended_module_qualified_names,
+          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