rucoa 0.10.0 → 0.12.0

data/lib/rucoa/configuration.rb

@@ -36,6 +36,11 @@ module Rucoa
       disable_feature('formatting')
     end
 
+    # @return [void]
+    def disable_highlight
+      disable_feature('highlight')
+    end
+
     # @return [void]
     def disable_hover
       disable_feature('hover')
@@ -58,18 +63,6 @@ module Rucoa
       @settings['base']['debug'] = true
     end
 
-    # @return [Boolean]
-    # @example returns false if the configuration is empty
-    #   configuration = Rucoa::Configuration.new
-    #   expect(configuration).not_to be_enables_debug
-    # @example returns true if the configuration enables debug
-    #   configuration = Rucoa::Configuration.new
-    #   configuration.update('base' => { 'debug' => true })
-    #   expect(configuration).to be_enables_debug
-    def enables_debug?
-      fetch('base', 'debug', default: false)
-    end
-
     # @return [Boolean]
     # @example returns true if the configuration is empty
     #   configuration = Rucoa::Configuration.new
@@ -87,6 +80,18 @@ module Rucoa
       enables_feature?('completion')
     end
 
+    # @return [Boolean]
+    # @example returns false if the configuration is empty
+    #   configuration = Rucoa::Configuration.new
+    #   expect(configuration).not_to be_enables_debug
+    # @example returns true if the configuration enables debug
+    #   configuration = Rucoa::Configuration.new
+    #   configuration.update('base' => { 'debug' => true })
+    #   expect(configuration).to be_enables_debug
+    def enables_debug?
+      fetch('base', 'debug', default: false)
+    end
+
     # @return [Boolean]
     def enables_definition?
       enables_feature?('definition')
@@ -107,6 +112,11 @@ module Rucoa
       enables_feature?('formatting')
     end
 
+    # @return [Boolean]
+    def enables_highlight?
+      enables_feature?('highlight')
+    end
+
     # @return [Boolean]
     def enables_hover?
       enables_feature?('hover')

data/lib/rucoa/definition_store.rb

@@ -7,11 +7,6 @@ module Rucoa
       @qualified_names_by_uri = ::Hash.new { |hash, key| hash[key] = [] }
     end
 
-    # @return [String]
-    def inspect
-      "#<#{self.class} definitions_count=#{@definition_by_qualified_name.count}>"
-    end
-
     # @param definitions [Array<Rucoa::Definition::Base>]
     # @return [void]
     def bulk_add(definitions)
@@ -23,61 +18,12 @@ module Rucoa
       end
     end
 
-    # @param source [Rucoa::Source]
-    # @return [void]
-    # @example resolves super class name from definitions
-    #   definition_store = Rucoa::DefinitionStore.new
-    #   foo = Rucoa::Source.new(
-    #     content: <<~RUBY,
-    #       module A
-    #         class Foo
-    #         end
-    #       end
-    #     RUBY
-    #     uri: 'file:///path/to/a/foo.rb',
-    #   )
-    #   definition_store.update_from(foo)
-    #   bar = Rucoa::Source.new(
-    #     content: <<~RUBY,
-    #       module A
-    #         class Bar < Foo
-    #         end
-    #       end
-    #     RUBY
-    #     uri: 'file:///path/to/a/bar.rb',
-    #   )
-    #   definition_store.update_from(bar)
-    #   definition = definition_store.find_definition_by_qualified_name('A::Bar')
-    #   expect(definition.super_class_qualified_name).to eq('A::Foo')
-    # @example resolves included module names from definitions
-    #   definition_store = Rucoa::DefinitionStore.new
-    #   foo = Rucoa::Source.new(
-    #     content: <<~RUBY,
-    #       module A
-    #         module Foo
-    #         end
-    #       end
-    #     RUBY
-    #     uri: 'file:///path/to/a/foo.rb',
-    #   )
-    #   definition_store.update_from(foo)
-    #   bar = Rucoa::Source.new(
-    #     content: <<~RUBY,
-    #       module A
-    #         class Bar
-    #           include Foo
-    #         end
-    #       end
-    #     RUBY
-    #     uri: 'file:///path/to/a/bar.rb',
-    #   )
-    #   definition_store.update_from(bar)
-    #   definition = definition_store.find_definition_by_qualified_name('A::Bar')
-    #   expect(definition.included_module_qualified_names).to eq(%w[A::Foo])
-    def update_from(source)
-      delete_definitions_in(source)
-      add_definitions_in(source)
-      resolve_constants_in(source)
+    # @param namespace [String]
+    # @return [Array<Rucoa::Definitions::ConstantDefinition>] e.g. File::Separator, File::SEPARATOR, etc.
+    def constant_definitions_under(namespace)
+      constant_definitions.select do |constant_definition|
+        constant_definition.namespace == namespace
+      end
     end
 
     # @param qualified_name [String]
@@ -178,18 +124,83 @@ module Rucoa
       end
     end
 
+    # @return [String]
+    def inspect
+      "#<#{self.class} definitions_count=#{@definition_by_qualified_name.count}>"
+    end
+
     # @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.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('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.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,68 +208,172 @@ 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
+
+    # @todo Search ancestors.
+    # @param unqualified_name [Rucoa::UnqualifiedName]
+    # @return [String]
+    def resolve_constant(unqualified_name)
+      (
+        unqualified_name.module_nesting.map do |prefix|
+          "#{prefix}::#{unqualified_name.chained_name}"
+        end + [unqualified_name.chained_name]
+      ).find do |candidate|
+        find_definition_by_qualified_name(candidate)
+      end || unqualified_name.chained_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.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('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.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
-
-    # @param namespace [String]
-    # @return [Array<Rucoa::Definitions::ConstantDefinition>] e.g. File::Separator, File::SEPARATOR, etc.
-    def constant_definitions_under(namespace)
-      constant_definitions.select do |constant_definition|
-        constant_definition.namespace == namespace
-      end
+      end.uniq(&:method_name)
     end
 
-    # @param unqualified_name [Rucoa::UnqualifiedName]
-    # @return [String]
-    def resolve_constant(unqualified_name)
-      (
-        unqualified_name.module_nesting.map do |prefix|
-          "#{prefix}::#{unqualified_name.chained_name}"
-        end + [unqualified_name.chained_name]
-      ).find do |candidate|
-        find_definition_by_qualified_name(candidate)
-      end || unqualified_name.chained_name
+    # @param source [Rucoa::Source]
+    # @return [void]
+    # @example resolves super class name from definitions
+    #   definition_store = Rucoa::DefinitionStore.new
+    #   foo = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       module A
+    #         class Foo
+    #         end
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/a/foo.rb',
+    #   )
+    #   definition_store.update_from(foo)
+    #   bar = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       module A
+    #         class Bar < Foo
+    #         end
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/a/bar.rb',
+    #   )
+    #   definition_store.update_from(bar)
+    #   definition = definition_store.find_definition_by_qualified_name('A::Bar')
+    #   expect(definition.super_class_qualified_name).to eq('A::Foo')
+    # @example resolves included module names from definitions
+    #   definition_store = Rucoa::DefinitionStore.new
+    #   foo = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       module A
+    #         module Foo
+    #         end
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/a/foo.rb',
+    #   )
+    #   definition_store.update_from(foo)
+    #   bar = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       module A
+    #         class Bar
+    #           include Foo
+    #         end
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/a/bar.rb',
+    #   )
+    #   definition_store.update_from(bar)
+    #   definition = definition_store.find_definition_by_qualified_name('A::Bar')
+    #   expect(definition.included_module_qualified_names).to eq(%w[A::Foo])
+    def update_from(source)
+      delete_definitions_in(source)
+      add_definitions_in(source)
+      resolve_constants_in(source)
     end
 
     private
 
     # @param source [Rucoa::Source]
     # @return [void]
-    def delete_definitions_in(source)
-      @qualified_names_by_uri[source.uri].each do |qualified_name|
-        @definition_by_qualified_name.delete(qualified_name)
+    def add_definitions_in(source)
+      source.definitions.group_by do |definition|
+        definition.location.uri
+      end.each do |uri, definitions|
+        @qualified_names_by_uri[uri] += definitions.map(&:qualified_name)
+        definitions.each do |definition|
+          @definition_by_qualified_name[definition.qualified_name] = definition
+        end
       end
-      @qualified_names_by_uri.delete(source.uri)
-    end
-
-    # @param type [String]
-    # @return [String, nil]
-    def singleton_class_name_from(type)
-      type[/singleton<(\w+)>/, 1]
     end
 
     # @param definition [Rucoa::Definitions::Class, Rucoa::Definitions::Module]
@@ -273,32 +388,9 @@ module Rucoa
       end
     end
 
-    # @param definition [Rucoa::Definitions::Class, Rucoa::Definitions::Module]
-    # @return [Array<Rucoa::Definitions::Class, Rucoa::Definitions::Module>] An array of prepended, itself, and included definitions
-    def module_ancestors_of(definition)
-      [
-        *definition.prepended_module_qualified_names.filter_map do |qualified_name|
-          find_definition_by_qualified_name(qualified_name)
-        end.reverse,
-        definition,
-        *definition.included_module_qualified_names.filter_map do |qualified_name|
-          find_definition_by_qualified_name(qualified_name)
-        end.reverse
-      ]
-    end
-
-    # @param definition [Rucoa::Definitions::Class]
-    # @return [Array<Rucoa::Definitions::Class>] super "class"es (not including modules) in closest-first order
-    def super_class_definitions_of(definition)
-      result = []
-      while (super_class_qualified_name = definition.super_class_qualified_name)
-        super_definition = find_definition_by_qualified_name(super_class_qualified_name)
-        break unless super_definition
-
-        result << super_definition
-        definition = super_definition
-      end
-      result
+    # @return [Array<Rucoa::Definition::ConstantDefinition>]
+    def constant_definitions
+      definitions.grep(Definitions::ConstantDefinition)
     end
 
     # @return [Array<Rucoa::Definitions::Base>]
@@ -306,37 +398,32 @@ module Rucoa
       @definition_by_qualified_name.values
     end
 
-    # @return [Array<Rucoa::Definition::MethodDefinition>]
-    def method_definitions
-      definitions.grep(Definitions::MethodDefinition)
-    end
-
-    # @return [Array<Rucoa::Definition::MethodDefinition>]
-    def instance_method_definitions
-      method_definitions.select(&:instance_method?)
+    # @param source [Rucoa::Source]
+    # @return [void]
+    def delete_definitions_in(source)
+      @qualified_names_by_uri[source.uri].each do |qualified_name|
+        @definition_by_qualified_name.delete(qualified_name)
+      end
+      @qualified_names_by_uri.delete(source.uri)
     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)
+    def method_definitions
+      definitions.grep(Definitions::MethodDefinition)
     end
 
-    # @param source [Rucoa::Source]
-    # @return [void]
-    def add_definitions_in(source)
-      source.definitions.group_by do |definition|
-        definition.location.uri
-      end.each do |uri, definitions|
-        @qualified_names_by_uri[uri] += definitions.map(&:qualified_name)
-        definitions.each do |definition|
-          @definition_by_qualified_name[definition.qualified_name] = definition
-        end
-      end
+    # @param definition [Rucoa::Definitions::Class, Rucoa::Definitions::Module]
+    # @return [Array<Rucoa::Definitions::Class, Rucoa::Definitions::Module>] An array of prepended, itself, and included definitions
+    def module_ancestors_of(definition)
+      [
+        *definition.prepended_module_qualified_names.filter_map do |qualified_name|
+          find_definition_by_qualified_name(qualified_name)
+        end.reverse,
+        definition,
+        *definition.included_module_qualified_names.filter_map do |qualified_name|
+          find_definition_by_qualified_name(qualified_name)
+        end.reverse
+      ]
     end
 
     # @param source [Rucoa::Source]
@@ -348,6 +435,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
@@ -359,5 +451,25 @@ module Rucoa
         definition.prepended_module_unqualified_names = []
       end
     end
+
+    # @param type [String]
+    # @return [String, nil]
+    def singleton_class_name_from(type)
+      type[/singleton<([\w:]+)>/, 1]
+    end
+
+    # @param definition [Rucoa::Definitions::Class]
+    # @return [Array<Rucoa::Definitions::Class>] super "class"es (not including modules) in closest-first order
+    def super_class_definitions_of(definition)
+      result = []
+      while (super_class_qualified_name = definition.super_class_qualified_name)
+        super_definition = find_definition_by_qualified_name(super_class_qualified_name)
+        break unless super_definition
+
+        result << super_definition
+        definition = super_definition
+      end
+      result
+    end
   end
 end

data/lib/rucoa/definitions/method_definition.rb

@@ -30,6 +30,17 @@ module Rucoa
         @types = types
       end
 
+      # @return [Boolean]
+      def instance_method?
+        @kind == :instance
+      end
+
+      # @todo
+      # @return [Array<Rucoa::Definitions::MethodParameter>]
+      def parameters
+        []
+      end
+
       # @return [String]
       # @example returns qualified name of method
       #   definition = Rucoa::Source.new(
@@ -52,12 +63,6 @@ module Rucoa
         ].join
       end
 
-      # @todo
-      # @return [Array<Rucoa::Definitions::MethodParameter>]
-      def parameters
-        []
-      end
-
       # @return [Array<String>]
       # @example returns return types
       #   definition = Rucoa::Source.new(
@@ -105,11 +110,6 @@ module Rucoa
         end
       end
 
-      # @return [Boolean]
-      def instance_method?
-        @kind == :instance
-      end
-
       # @return [Boolean]
       def singleton_method?
         !instance_method?

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/handler_concerns/configuration_requestable.rb

@@ -7,6 +7,13 @@ module Rucoa
 
       private
 
+      # @return [void]
+      def publish_diagnostics_on_each_source
+        source_store.each_uri do |uri|
+          publish_diagnostics_on(uri)
+        end
+      end
+
       # @return [void]
       def request_workspace_configuration
         write(
@@ -23,13 +30,6 @@ module Rucoa
           publish_diagnostics_on_each_source
         end
       end
-
-      # @return [void]
-      def publish_diagnostics_on_each_source
-        source_store.each_uri do |uri|
-          publish_diagnostics_on(uri)
-        end
-      end
     end
   end
 end