rucoa 0.10.0 → 0.11.0

data/lib/rucoa/definition_store.rb

@@ -180,16 +180,76 @@ module Rucoa
 
     # @param type [String]
     # @return [Array<Rucoa::Definitions::MethodDefinition>]
-    # @example includes ancestors' methods
+    # @example supports simple instance method
+    #   source = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       class A
+    #         def foo
+    #         end
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/example.rb'
+    #   )
+    #   definition_store = Rucoa::DefinitionStore.new
+    #   definition_store.update_from(source)
+    #   subject = definition_store.instance_method_definitions_of('A')
+    #   expect(subject.map(&:qualified_name)).to eq(%w[A#foo])
+    # @example supports inheritance
+    #   source = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       class A
+    #         def foo
+    #         end
+    #       end
+    #
+    #       class B < A
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/example.rb'
+    #   )
+    #   definition_store = Rucoa::DefinitionStore.new
+    #   definition_store.update_from(source)
+    #   subject = definition_store.instance_method_definitions_of('B')
+    #   expect(subject.map(&:qualified_name)).to eq(%w[A#foo])
+    # @example supports `include`
+    #   source = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       module A
+    #         def foo
+    #         end
+    #       end
+    #
+    #       class B
+    #         include A
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/example.rb'
+    #   )
     #   definition_store = Rucoa::DefinitionStore.new
-    #   definition_store.bulk_add(Rucoa::DefinitionArchiver.load)
-    #   subject = definition_store.instance_method_definitions_of('File')
-    #   expect(subject.map(&:qualified_name)).to include('IO#raw')
-    # @example responds to `singleton<File>`
+    #   definition_store.update_from(source)
+    #   subject = definition_store.instance_method_definitions_of('B')
+    #   expect(subject.map(&:qualified_name)).to eq(%w[A#foo])
+    # @example supports `prepend`
+    #   source = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       module A
+    #         def foo
+    #         end
+    #       end
+    #
+    #       class B
+    #         prepend A
+    #
+    #         def foo
+    #         end
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/example.rb'
+    #   )
     #   definition_store = Rucoa::DefinitionStore.new
-    #   definition_store.bulk_add(Rucoa::DefinitionArchiver.load)
-    #   subject = definition_store.instance_method_definitions_of('singleton<File>')
-    #   expect(subject.map(&:qualified_name)).to include('IO.write')
+    #   definition_store.update_from(source)
+    #   subject = definition_store.instance_method_definitions_of('B')
+    #   expect(subject.map(&:qualified_name)).to eq(%w[A#foo])
     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
@@ -197,31 +257,87 @@ module Rucoa
       class_or_module_definition = find_definition_by_qualified_name(type)
       return [] unless class_or_module_definition
 
-      method_definitions = instance_method_definitions
+      method_definitions = self.method_definitions
       ancestors_of(class_or_module_definition).flat_map do |ancestor|
         method_definitions.select do |method_definition|
-          method_definition.namespace == ancestor.qualified_name
+          method_definition.namespace == ancestor.qualified_name &&
+            method_definition.instance_method?
         end
-      end
+      end.uniq(&:method_name)
     end
 
     # @param type [String]
     # @return [Array<Rucoa::Definitions::MethodDefinition>]
-    # @example returns singleton method definitions of File
+    # @example supports simple singleton method
+    #   source = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       class A
+    #         def self.foo
+    #         end
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/example.rb'
+    #   )
+    #   definition_store = Rucoa::DefinitionStore.new
+    #   definition_store.update_from(source)
+    #   subject = definition_store.singleton_method_definitions_of('A')
+    #   expect(subject.map(&:qualified_name)).to include('A.foo')
+    # @example supports super class's singleton method
+    #   source = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       class A
+    #         def self.foo
+    #         end
+    #       end
+    #
+    #       class B < A
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/example.rb'
+    #   )
+    #   definition_store = Rucoa::DefinitionStore.new
+    #   definition_store.update_from(source)
+    #   subject = definition_store.singleton_method_definitions_of('B')
+    #   expect(subject.map(&:qualified_name)).to include('A.foo')
+    # @example supports extended module's instance method
+    #   source = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       module A
+    #         def foo
+    #         end
+    #       end
+    #
+    #       class B
+    #         def self.foo
+    #         end
+    #       end
+    #
+    #       class C < B
+    #         extend A
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/example.rb'
+    #   )
     #   definition_store = Rucoa::DefinitionStore.new
-    #   definition_store.bulk_add(Rucoa::DefinitionArchiver.load)
-    #   subject = definition_store.singleton_method_definitions_of('File')
-    #   expect(subject.map(&:qualified_name)).to include('IO.write')
+    #   definition_store.update_from(source)
+    #   subject = definition_store.singleton_method_definitions_of('C')
+    #   expect(subject.map(&:qualified_name)).to eq(%w[A#foo])
     def singleton_method_definitions_of(type)
       class_or_module_definition = find_definition_by_qualified_name(type)
       return [] unless class_or_module_definition
 
-      method_definitions = singleton_method_definitions
+      method_definitions = self.method_definitions
       ancestors_of(class_or_module_definition).flat_map do |ancestor|
         method_definitions.select do |method_definition|
-          method_definition.namespace == ancestor.qualified_name
+          method_definition.namespace == ancestor.qualified_name &&
+            method_definition.singleton_method?
+        end + ancestor.extended_module_qualified_names.flat_map do |extended_module_qualified_name|
+          method_definitions.select do |method_definition|
+            method_definition.namespace == extended_module_qualified_name &&
+              method_definition.instance_method?
+          end
         end
-      end
+      end.uniq(&:method_name)
     end
 
     # @param namespace [String]
@@ -232,6 +348,7 @@ module Rucoa
       end
     end
 
+    # @todo Search ancestors.
     # @param unqualified_name [Rucoa::UnqualifiedName]
     # @return [String]
     def resolve_constant(unqualified_name)
@@ -258,7 +375,7 @@ module Rucoa
     # @param type [String]
     # @return [String, nil]
     def singleton_class_name_from(type)
-      type[/singleton<(\w+)>/, 1]
+      type[/singleton<([\w:]+)>/, 1]
     end
 
     # @param definition [Rucoa::Definitions::Class, Rucoa::Definitions::Module]
@@ -311,16 +428,6 @@ 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
-
     # @return [Array<Rucoa::Definition::ConstantDefinition>]
     def constant_definitions
       definitions.grep(Definitions::ConstantDefinition)
@@ -348,6 +455,11 @@ module Rucoa
         definition.super_class_qualified_name = resolve_constant(definition.super_class_unqualified_name)
         definition.super_class_unqualified_name = nil
 
+        definition.extended_module_qualified_names = definition.extended_module_unqualified_names.map do |unqualified_name|
+          resolve_constant(unqualified_name)
+        end
+        definition.extended_module_unqualified_names = []
+
         definition.included_module_qualified_names = definition.included_module_unqualified_names.map do |unqualified_name|
           resolve_constant(unqualified_name)
         end

data/lib/rucoa/definitions/module_definition.rb

@@ -3,6 +3,12 @@
 module Rucoa
   module Definitions
     class ModuleDefinition < ConstantDefinition
+      # @return [Array<String>]
+      attr_accessor :extended_module_qualified_names
+
+      # @return [Array<Rucoa::UnqualifiedName>]
+      attr_accessor :extended_module_unqualified_names
+
       # @return [Array<String>]
       attr_accessor :included_module_qualified_names
 
@@ -15,11 +21,15 @@ module Rucoa
       # @return [Array<Rucoa::UnqualifiedName>]
       attr_accessor :prepended_module_unqualified_names
 
+      # @param extended_module_qualified_names [Array<String>]
+      # @param extended_module_unqualified_names [Array<String>]
       # @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(
+        extended_module_qualified_names: [],
+        extended_module_unqualified_names: [],
         included_module_qualified_names: [],
         included_module_unqualified_names: [],
         prepended_module_qualified_names: [],
@@ -27,6 +37,8 @@ module Rucoa
         **keyword_arguments
       )
         super(**keyword_arguments)
+        @extended_module_qualified_names = extended_module_qualified_names
+        @extended_module_unqualified_names = extended_module_unqualified_names
         @included_module_qualified_names = included_module_qualified_names
         @included_module_unqualified_names = included_module_unqualified_names
         @prepended_module_qualified_names = prepended_module_qualified_names
@@ -36,6 +48,8 @@ module Rucoa
       # @param other [Rucoa::Definitions::ModuleDefinition]
       # @return [Rucoa::Definitions::ModuleDefinition]
       def merge!(other)
+        self.extended_module_qualified_names |= other.extended_module_qualified_names
+        self.extended_module_unqualified_names |= other.extended_module_unqualified_names
         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

data/lib/rucoa/node_inspector.rb

@@ -51,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
@@ -113,6 +113,17 @@ module Rucoa
       @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
       qualified_name = nearest_def_qualified_name

data/lib/rucoa/rbs/class_definition_mapper.rb

@@ -12,6 +12,7 @@ module Rucoa
       def call
         Definitions::ClassDefinition.new(
           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,

data/lib/rucoa/rbs/module_definition_mapper.rb

@@ -20,6 +20,7 @@ module Rucoa
       def call
         Definitions::ModuleDefinition.new(
           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,
@@ -44,21 +45,25 @@ module Rucoa
         Location.from_rbs_location(@declaration.location)
       end
 
+      # @return [Array<String>]
+      def extended_module_qualified_names
+        module_qualified_names_for(::RBS::AST::Members::Extend)
+      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
+        module_qualified_names_for(::RBS::AST::Members::Include)
       end
 
       # @return [Array<String>]
       def prepended_module_qualified_names
+        module_qualified_names_for(::RBS::AST::Members::Prepend)
+      end
+
+      def module_qualified_names_for(member_class)
         @declaration.members.filter_map do |member|
           case member
-          when ::RBS::AST::Members::Prepend
+          when member_class
             member.name.to_s.delete_prefix('::')
           end
         end

data/lib/rucoa/server.rb

@@ -43,8 +43,8 @@ module Rucoa
     # @param io_in [IO]
     # @param io_out [IO]
     def initialize(
-      io_log: ::StringIO.new,
       io_in: ::StringIO.new,
+      io_log: ::StringIO.new,
       io_out: ::StringIO.new
     )
       @logger = ::Logger.new(io_log)

data/lib/rucoa/version.rb

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

data/lib/rucoa/yard/definition_generators/attribute_reader_definition_generator.rb

@@ -35,10 +35,26 @@ module Rucoa
         #       Foo#bar=
         #     ]
         #   )
+        # @example ignores unrecognizable attributes
+        #   definitions = Rucoa::Source.new(
+        #     content: <<~RUBY,
+        #       class Foo
+        #         attr_reader foo
+        #       end
+        #     RUBY
+        #     uri: '/path/to/foo.rb'
+        #   ).definitions
+        #   expect(definitions.map(&:qualified_name)).to eq(
+        #     %w[
+        #       Foo
+        #     ]
+        #   )
         def call
           return [] unless @node.is_a?(Nodes::SendNode) && READER_METHOD_NAMES.include?(@node.name)
 
-          @node.arguments.map do |argument|
+          @node.arguments.filter_map do |argument|
+            next unless argument.respond_to?(:value)
+
             Definitions::MethodDefinition.new(
               description: description,
               kind: :instance,

data/lib/rucoa/yard/definition_generators/attribute_writer_definition_generator.rb

@@ -35,10 +35,26 @@ module Rucoa
         #       Foo#bar=
         #     ]
         #   )
+        # @example ignores unrecognizable attributes
+        #   definitions = Rucoa::Source.new(
+        #     content: <<~RUBY,
+        #       class Foo
+        #         attr_writer foo
+        #       end
+        #     RUBY
+        #     uri: '/path/to/foo.rb'
+        #   ).definitions
+        #   expect(definitions.map(&:qualified_name)).to eq(
+        #     %w[
+        #       Foo
+        #     ]
+        #   )
         def call
           return [] unless @node.is_a?(Nodes::SendNode) && WRITER_METHOD_NAMES.include?(@node.name)
 
-          @node.arguments.map do |argument|
+          @node.arguments.filter_map do |argument|
+            next unless argument.respond_to?(:value)
+
             Definitions::MethodDefinition.new(
               description: description,
               kind: :instance,

data/lib/rucoa/yard/definition_generators/class_definition_generator.rb

@@ -49,6 +49,7 @@ module Rucoa
           [
             Definitions::ClassDefinition.new(
               description: description,
+              extended_module_unqualified_names: extended_module_unqualified_names,
               included_module_unqualified_names: included_module_unqualified_names,
               location: location,
               prepended_module_unqualified_names: prepended_module_unqualified_names,

data/lib/rucoa/yard/definition_generators/method_definition_generator.rb

@@ -22,6 +22,19 @@ module Rucoa
         #     uri: '/path/to/foo.rb'
         #   ).definitions
         #   expect(definitions[0]).to be_a(Rucoa::Definitions::MethodDefinition)
+        # @example returns method definition for another style of singleton def node
+        #   definitions = Rucoa::Source.new(
+        #     content: <<~RUBY,
+        #       class Foo
+        #         class << self
+        #           def bar
+        #           end
+        #         end
+        #       end
+        #     RUBY
+        #     uri: '/path/to/foo.rb'
+        #   ).definitions
+        #   expect(definitions[1].qualified_name).to eq('Foo.bar')
         def call
           return [] unless @node.is_a?(Nodes::DefNode) || @node.is_a?(Nodes::DefsNode)
 

data/lib/rucoa/yard/definition_generators/module_definition_generator.rb

@@ -19,6 +19,7 @@ module Rucoa
           [
             Definitions::ModuleDefinition.new(
               description: description,
+              extended_module_unqualified_names: extended_module_unqualified_names,
               included_module_unqualified_names: included_module_unqualified_names,
               location: location,
               prepended_module_unqualified_names: prepended_module_unqualified_names,
@@ -29,6 +30,11 @@ module Rucoa
 
         private
 
+        # @return [Array<Rucoa::UnqualifiedName>]
+        def extended_module_unqualified_names
+          unqualified_names_for('extend')
+        end
+
         # @return [Array<Rucoa::UnqualifiedName>]
         def included_module_unqualified_names
           unqualified_names_for('include')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rucoa
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Ryo Nakamura
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-09-24 00:00:00.000000000 Z
+date: 2022-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser