solargraph 0.59.1 → 0.60.0

data/lib/solargraph/convention/active_support_concern.rb

@@ -1,111 +1,111 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Convention
-    # ActiveSupport::Concern is syntactic sugar for a common
-    # pattern to include class methods while mixing-in a Module
-    # See https://api.rubyonrails.org/classes/ActiveSupport/Concern.html
-    class ActiveSupportConcern < Base
-      include Logging
-
-      # @return [Array<Pin::Base>]
-      attr_reader :pins
-
-      # @param api_map [ApiMap]
-      # @param rooted_tag [String]
-      # @param scope [Symbol] :class or :instance
-      # @param visibility [Array<Symbol>] :public, :protected, and/or :private
-      # @param deep [Boolean] whether to include methods from included modules
-      # @param skip [Set<String>]
-      # @param _no_core [Boolean]n whether to skip core methods
-      def object api_map, rooted_tag, scope, visibility, deep, skip, _no_core
-        moo = ObjectProcessor.new(api_map, rooted_tag, scope, visibility, deep, skip)
-        moo.environ
-      end
-
-      # yard-activesupport-concern pulls methods inside
-      # 'class_methods' blocks into main class visible from YARD
-      #
-      # @param _doc_map [DocMap]
-      def global _doc_map
-        Environ.new(yard_plugins: ['activesupport-concern'])
-      end
-
-      # Process an object to add any class methods brought in via
-      # ActiveSupport::Concern
-      class ObjectProcessor
-        include Logging
-
-        attr_reader :environ
-
-        # @param api_map [ApiMap]
-        # @param rooted_tag [String] the tag of the class or module being processed
-        # @param scope [Symbol] :class or :instance
-        # @param visibility [Array<Symbol>] :public, :protected, and/or :private
-        # @param deep [Boolean] whether to include methods from included modules
-        # @param skip [Set<String>] a set of tags to skip
-        def initialize api_map, rooted_tag, scope, visibility, deep, skip
-          @api_map = api_map
-          @rooted_tag = rooted_tag
-          @scope = scope
-          @visibility = visibility
-          @deep = deep
-          @skip = skip
-
-          @environ = Environ.new
-          return unless scope == :class
-
-          @rooted_type = ComplexType.parse(rooted_tag).force_rooted
-          @fqns = rooted_type.namespace
-          @namespace_pin = api_map.get_path_pins(fqns).select { |p| p.is_a?(Pin::Namespace) }.first
-
-          api_map.get_includes(fqns).reverse.each do |include_tag|
-            process_include include_tag
-          end
-        end
-
-        private
-
-        attr_reader :api_map, :rooted_tag, :rooted_type, :scope,
-                    :visibility, :deep, :skip, :namespace_pin,
-                    :fqns
-
-        # @param include_tag [Pin::Reference::Include] the include reference pin
-        #
-        # @return [void]
-        def process_include include_tag
-          rooted_include_tag = api_map.dereference(include_tag)
-          return if rooted_include_tag.nil?
-          logger.debug do
-            "ActiveSupportConcern#object(#{fqns}, #{scope}, #{visibility}, #{deep}) - " \
-              "Handling class include include_tag=#{include_tag}"
-          end
-          module_extends = api_map.get_extends(rooted_include_tag).map(&:type).map(&:to_s)
-          logger.debug do
-            "ActiveSupportConcern#object(#{fqns}, #{scope}, #{visibility}, #{deep}) - " \
-              "found module extends of #{rooted_include_tag}: #{module_extends}"
-          end
-          return unless module_extends.include? 'ActiveSupport::Concern'
-          included_class_pins = api_map.inner_get_methods_from_reference(rooted_include_tag, namespace_pin, rooted_type,
-                                                                         :class, visibility, deep, skip, true)
-          logger.debug do
-            "ActiveSupportConcern#object(#{fqns}, #{scope}, #{visibility}, #{deep}) - " \
-              "Found #{included_class_pins.length} inluded class methods for #{rooted_include_tag}"
-          end
-          environ.pins.concat included_class_pins
-          # another pattern is to put class methods inside a submodule
-          classmethods_include_tag = "#{rooted_include_tag}::ClassMethods"
-          included_classmethods_pins =
-            api_map.inner_get_methods_from_reference(classmethods_include_tag, namespace_pin, rooted_type,
-                                                     :instance, visibility, deep, skip, true)
-          logger.debug do
-            "ActiveSupportConcern#object(#{fqns}, #{scope}, #{visibility}, #{deep}) - " \
-              "Found #{included_classmethods_pins.length} included classmethod " \
-              "class methods for #{classmethods_include_tag}"
-          end
-          environ.pins.concat included_classmethods_pins
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    # ActiveSupport::Concern is syntactic sugar for a common
+    # pattern to include class methods while mixing-in a Module
+    # See https://api.rubyonrails.org/classes/ActiveSupport/Concern.html
+    class ActiveSupportConcern < Base
+      include Logging
+
+      # @return [Array<Pin::Base>]
+      attr_reader :pins
+
+      # @param api_map [ApiMap]
+      # @param rooted_tag [String]
+      # @param scope [Symbol] :class or :instance
+      # @param visibility [Array<Symbol>] :public, :protected, and/or :private
+      # @param deep [Boolean] whether to include methods from included modules
+      # @param skip [Set<String>]
+      # @param _no_core [Boolean]n whether to skip core methods
+      def object api_map, rooted_tag, scope, visibility, deep, skip, _no_core
+        moo = ObjectProcessor.new(api_map, rooted_tag, scope, visibility, deep, skip)
+        moo.environ
+      end
+
+      # yard-activesupport-concern pulls methods inside
+      # 'class_methods' blocks into main class visible from YARD
+      #
+      # @param _doc_map [DocMap]
+      def global _doc_map
+        Environ.new(yard_plugins: ['activesupport-concern'])
+      end
+
+      # Process an object to add any class methods brought in via
+      # ActiveSupport::Concern
+      class ObjectProcessor
+        include Logging
+
+        attr_reader :environ
+
+        # @param api_map [ApiMap]
+        # @param rooted_tag [String] the tag of the class or module being processed
+        # @param scope [Symbol] :class or :instance
+        # @param visibility [Array<Symbol>] :public, :protected, and/or :private
+        # @param deep [Boolean] whether to include methods from included modules
+        # @param skip [Set<String>] a set of tags to skip
+        def initialize api_map, rooted_tag, scope, visibility, deep, skip
+          @api_map = api_map
+          @rooted_tag = rooted_tag
+          @scope = scope
+          @visibility = visibility
+          @deep = deep
+          @skip = skip
+
+          @environ = Environ.new
+          return unless scope == :class
+
+          @rooted_type = ComplexType.parse(rooted_tag).force_rooted
+          @fqns = rooted_type.namespace
+          @namespace_pin = api_map.get_path_pins(fqns).select { |p| p.is_a?(Pin::Namespace) }.first
+
+          api_map.get_includes(fqns).reverse.each do |include_tag|
+            process_include include_tag
+          end
+        end
+
+        private
+
+        attr_reader :api_map, :rooted_tag, :rooted_type, :scope,
+                    :visibility, :deep, :skip, :namespace_pin,
+                    :fqns
+
+        # @param include_tag [Pin::Reference::Include] the include reference pin
+        #
+        # @return [void]
+        def process_include include_tag
+          rooted_include_tag = api_map.dereference(include_tag)
+          return if rooted_include_tag.nil?
+          logger.debug do
+            "ActiveSupportConcern#object(#{fqns}, #{scope}, #{visibility}, #{deep}) - " \
+              "Handling class include include_tag=#{include_tag}"
+          end
+          module_extends = api_map.get_extends(rooted_include_tag).map(&:type).map(&:to_s)
+          logger.debug do
+            "ActiveSupportConcern#object(#{fqns}, #{scope}, #{visibility}, #{deep}) - " \
+              "found module extends of #{rooted_include_tag}: #{module_extends}"
+          end
+          return unless module_extends.include? 'ActiveSupport::Concern'
+          included_class_pins = api_map.inner_get_methods_from_reference(rooted_include_tag, namespace_pin, rooted_type,
+                                                                         :class, visibility, deep, skip, true)
+          logger.debug do
+            "ActiveSupportConcern#object(#{fqns}, #{scope}, #{visibility}, #{deep}) - " \
+              "Found #{included_class_pins.length} inluded class methods for #{rooted_include_tag}"
+          end
+          environ.pins.concat included_class_pins
+          # another pattern is to put class methods inside a submodule
+          classmethods_include_tag = "#{rooted_include_tag}::ClassMethods"
+          included_classmethods_pins =
+            api_map.inner_get_methods_from_reference(classmethods_include_tag, namespace_pin, rooted_type,
+                                                     :instance, visibility, deep, skip, true)
+          logger.debug do
+            "ActiveSupportConcern#object(#{fqns}, #{scope}, #{visibility}, #{deep}) - " \
+              "Found #{included_classmethods_pins.length} included classmethod " \
+              "class methods for #{classmethods_include_tag}"
+          end
+          environ.pins.concat included_classmethods_pins
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/convention/base.rb

@@ -1,50 +1,50 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Convention
-    # The base class for Conventions.
-    #
-    # A Convention provides Environs that customize ApiMaps with additional
-    # pins and other information. Subclasses should implement the `local` and
-    # `global` methods as necessary.
-    #
-    class Base
-      EMPTY_ENVIRON = Environ.new
-
-      # The Environ for a source map.
-      # Subclasses can override this method.
-      #
-      # @param source_map [SourceMap]
-      # @return [Environ]
-      def local source_map
-        EMPTY_ENVIRON
-      end
-
-      # The Environ for a DocMap.
-      # Subclasses can override this method.
-      #
-      # @param doc_map [DocMap]
-      # @return [Environ]
-      def global doc_map
-        EMPTY_ENVIRON
-      end
-
-      # Provides any additional method pins based on e the described object.
-      #
-      # @param api_map [ApiMap]
-      # @param rooted_tag [String] A fully qualified namespace, with
-      #   generic parameter values if applicable
-      # @param scope [Symbol] :class or :instance
-      # @param visibility [Array<Symbol>] :public, :protected, and/or :private
-      # @param deep [Boolean]
-      # @param skip [Set<String>]
-      # @param no_core [Boolean] Skip core classes if true
-      #
-      # @return [Environ]
-      def object api_map, rooted_tag, scope, visibility,
-                 deep, skip, no_core
-        EMPTY_ENVIRON
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    # The base class for Conventions.
+    #
+    # A Convention provides Environs that customize ApiMaps with additional
+    # pins and other information. Subclasses should implement the `local` and
+    # `global` methods as necessary.
+    #
+    class Base
+      EMPTY_ENVIRON = Environ.new
+
+      # The Environ for a source map.
+      # Subclasses can override this method.
+      #
+      # @param source_map [SourceMap]
+      # @return [Environ]
+      def local source_map
+        EMPTY_ENVIRON
+      end
+
+      # The Environ for a DocMap.
+      # Subclasses can override this method.
+      #
+      # @param doc_map [DocMap]
+      # @return [Environ]
+      def global doc_map
+        EMPTY_ENVIRON
+      end
+
+      # Provides any additional method pins based on e the described object.
+      #
+      # @param api_map [ApiMap]
+      # @param rooted_tag [String] A fully qualified namespace, with
+      #   generic parameter values if applicable
+      # @param scope [Symbol] :class or :instance
+      # @param visibility [Array<Symbol>] :public, :protected, and/or :private
+      # @param deep [Boolean]
+      # @param skip [Set<String>]
+      # @param no_core [Boolean] Skip core classes if true
+      #
+      # @return [Environ]
+      def object api_map, rooted_tag, scope, visibility,
+                 deep, skip, no_core
+        EMPTY_ENVIRON
+      end
+    end
+  end
+end

data/lib/solargraph/diagnostics.rb

@@ -1,55 +1,55 @@
-# frozen_string_literal: true
-
-module Solargraph
-  # The Diagnostics library provides reporters for analyzing problems in code
-  # and providing the results to language server clients.
-  #
-  module Diagnostics
-    autoload :Base,            'solargraph/diagnostics/base'
-    autoload :Severities,      'solargraph/diagnostics/severities'
-    autoload :Rubocop,         'solargraph/diagnostics/rubocop'
-    autoload :RubocopHelpers,  'solargraph/diagnostics/rubocop_helpers'
-    autoload :RequireNotFound, 'solargraph/diagnostics/require_not_found'
-    autoload :UpdateErrors,    'solargraph/diagnostics/update_errors'
-    autoload :TypeCheck,       'solargraph/diagnostics/type_check'
-
-    class << self
-      # Add a reporter with a name to identify it in .solargraph.yml files.
-      #
-      # @param name [String] The name
-      # @param klass [Class<Solargraph::Diagnostics::Base>] The class implementation
-      # @return [void]
-      def register name, klass
-        reporter_hash[name] = klass
-      end
-
-      # Get an array of reporter names.
-      #
-      # @return [Array<String>]
-      def reporters
-        reporter_hash.keys - ['type_not_defined'] # @todo Hide type_not_defined for now
-      end
-
-      # Find a reporter by name.
-      #
-      # @param name [String] The name with which the reporter was registered
-      # @return [Class<Solargraph::Diagnostics::Base>, nil]
-      def reporter name
-        reporter_hash[name]
-      end
-
-      private
-
-      # @return [Hash{String => Class<Solargraph::Diagnostics::Base>}]
-      def reporter_hash
-        @reporter_hash ||= {}
-      end
-    end
-
-    register 'rubocop', Rubocop
-    register 'require_not_found', RequireNotFound
-    register 'typecheck', TypeCheck
-    register 'update_errors', UpdateErrors
-    register 'type_not_defined', TypeCheck # @todo Retained for backwards compatibility
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  # The Diagnostics library provides reporters for analyzing problems in code
+  # and providing the results to language server clients.
+  #
+  module Diagnostics
+    autoload :Base,            'solargraph/diagnostics/base'
+    autoload :Severities,      'solargraph/diagnostics/severities'
+    autoload :Rubocop,         'solargraph/diagnostics/rubocop'
+    autoload :RubocopHelpers,  'solargraph/diagnostics/rubocop_helpers'
+    autoload :RequireNotFound, 'solargraph/diagnostics/require_not_found'
+    autoload :UpdateErrors,    'solargraph/diagnostics/update_errors'
+    autoload :TypeCheck,       'solargraph/diagnostics/type_check'
+
+    class << self
+      # Add a reporter with a name to identify it in .solargraph.yml files.
+      #
+      # @param name [String] The name
+      # @param klass [Class<Solargraph::Diagnostics::Base>] The class implementation
+      # @return [void]
+      def register name, klass
+        reporter_hash[name] = klass
+      end
+
+      # Get an array of reporter names.
+      #
+      # @return [Array<String>]
+      def reporters
+        reporter_hash.keys - ['type_not_defined'] # @todo Hide type_not_defined for now
+      end
+
+      # Find a reporter by name.
+      #
+      # @param name [String] The name with which the reporter was registered
+      # @return [Class<Solargraph::Diagnostics::Base>, nil]
+      def reporter name
+        reporter_hash[name]
+      end
+
+      private
+
+      # @return [Hash{String => Class<Solargraph::Diagnostics::Base>}]
+      def reporter_hash
+        @reporter_hash ||= {}
+      end
+    end
+
+    register 'rubocop', Rubocop
+    register 'require_not_found', RequireNotFound
+    register 'typecheck', TypeCheck
+    register 'update_errors', UpdateErrors
+    register 'type_not_defined', TypeCheck # @todo Retained for backwards compatibility
+  end
+end

data/lib/solargraph/doc_map.rb

@@ -317,6 +317,7 @@ module Solargraph
       gemspec = Gem::Specification.find_by_path(path)
       if gemspec.nil?
         gem_name_guess = path.split('/').first
+        return nil if gem_name_guess.to_s.empty?
         begin
           # this can happen when the gem is included via a local path in
           # a Gemfile; Gem doesn't try to index the paths in that case.

data/lib/solargraph/environ.rb

@@ -1,52 +1,52 @@
-# frozen_string_literal: true
-
-module Solargraph
-  # A collection of additional data, such as map pins and required paths, that
-  # can be added to an ApiMap.
-  #
-  # Conventions are used to add Environs.
-  #
-  class Environ
-    # @return [Array<String>]
-    attr_reader :requires
-
-    # @return [Array<String>]
-    attr_reader :domains
-
-    # @return [Array<Pin::Base>]
-    attr_reader :pins
-
-    # @return [Array<String>]
-    attr_reader :yard_plugins
-
-    # @param requires [Array<String>]
-    # @param domains [Array<String>]
-    # @param pins [Array<Pin::Base>]
-    # @param yard_plugins [Array<String>]
-    def initialize requires: [], domains: [], pins: [], yard_plugins: []
-      @requires = requires
-      @domains = domains
-      @pins = pins
-      @yard_plugins = yard_plugins
-    end
-
-    # @return [self]
-    def clear
-      domains.clear
-      requires.clear
-      pins.clear
-      yard_plugins.clear
-      self
-    end
-
-    # @param other [Environ]
-    # @return [self]
-    def merge other
-      domains.concat other.domains
-      requires.concat other.requires
-      pins.concat other.pins
-      yard_plugins.concat other.yard_plugins
-      self
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  # A collection of additional data, such as map pins and required paths, that
+  # can be added to an ApiMap.
+  #
+  # Conventions are used to add Environs.
+  #
+  class Environ
+    # @return [Array<String>]
+    attr_reader :requires
+
+    # @return [Array<String>]
+    attr_reader :domains
+
+    # @return [Array<Pin::Base>]
+    attr_reader :pins
+
+    # @return [Array<String>]
+    attr_reader :yard_plugins
+
+    # @param requires [Array<String>]
+    # @param domains [Array<String>]
+    # @param pins [Array<Pin::Base>]
+    # @param yard_plugins [Array<String>]
+    def initialize requires: [], domains: [], pins: [], yard_plugins: []
+      @requires = requires
+      @domains = domains
+      @pins = pins
+      @yard_plugins = yard_plugins
+    end
+
+    # @return [self]
+    def clear
+      domains.clear
+      requires.clear
+      pins.clear
+      yard_plugins.clear
+      self
+    end
+
+    # @param other [Environ]
+    # @return [self]
+    def merge other
+      domains.concat other.domains
+      requires.concat other.requires
+      pins.concat other.pins
+      yard_plugins.concat other.yard_plugins
+      self
+    end
+  end
+end

data/lib/solargraph/gem_pins.rb

@@ -11,17 +11,6 @@ module Solargraph
       include Logging
     end
 
-    # @param pins [Array<Pin::Base>]
-    # @return [Array<Pin::Base>]
-    def self.combine_method_pins_by_path pins
-      method_pins, alias_pins = pins.partition { |pin| pin.instance_of?(Pin::Method) }
-      by_path = method_pins.group_by(&:path)
-      by_path.transform_values! do |pins|
-        GemPins.combine_method_pins(*pins)
-      end
-      by_path.values + alias_pins
-    end
-
     # @param pins [Array<Pin::Method>]
     # @return [Pin::Method, nil]
     def self.combine_method_pins(*pins)

data/lib/solargraph/language_server/message/extended/environment.rb

@@ -1,25 +1,25 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module LanguageServer
-    module Message
-      module Extended
-        # Update YARD documentation for installed gems. If the `rebuild`
-        # parameter is true, rebuild existing yardocs.
-        #
-        class Environment < Base
-          def process
-            # Make sure the environment page can report RuboCop's version
-            require 'rubocop'
-
-            page = Solargraph::Page.new(host.options['viewsPath'])
-            content = page.render('environment', layout: true, locals: { config: host.options, folders: host.folders })
-            set_result(
-              content: content
-            )
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module LanguageServer
+    module Message
+      module Extended
+        # Update YARD documentation for installed gems. If the `rebuild`
+        # parameter is true, rebuild existing yardocs.
+        #
+        class Environment < Base
+          def process
+            # Make sure the environment page can report RuboCop's version
+            require 'rubocop'
+
+            page = Solargraph::Page.new(host.options['viewsPath'])
+            content = page.render('environment', layout: true, locals: { config: host.options, folders: host.folders })
+            set_result(
+              content: content
+            )
+          end
+        end
+      end
+    end
+  end
+end