solargraph 0.54.0 → 0.58.0

data/lib/solargraph/yard_map/mapper/to_method.rb

@@ -6,7 +6,12 @@ module Solargraph
       module ToMethod
         extend YardMap::Helpers
 
-        # @param code_object [YARD::CodeObjects::Base]
+        VISIBILITY_OVERRIDE = {
+          # YARD pays attention to 'private' statements prior to class methods but shouldn't
+          ["Rails::Engine", :class, "find_root_with_flag"] => :public
+        }
+
+        # @param code_object [YARD::CodeObjects::MethodObject]
         # @param name [String, nil]
         # @param scope [Symbol, nil]
         # @param visibility [Symbol, nil]
@@ -14,31 +19,60 @@ module Solargraph
         # @param spec [Gem::Specification, nil]
         # @return [Solargraph::Pin::Method]
         def self.make code_object, name = nil, scope = nil, visibility = nil, closure = nil, spec = nil
-          closure ||= Solargraph::Pin::Namespace.new(
-            name: code_object.namespace.to_s,
-            gates: [code_object.namespace.to_s]
-          )
+          closure ||= create_closure_namespace_for(code_object, spec)
           location = object_location(code_object, spec)
           name ||= code_object.name.to_s
           return_type = ComplexType::SELF if name == 'new'
           comments = code_object.docstring ? code_object.docstring.all.to_s : ''
-          pin = Pin::Method.new(
-            location: location,
-            closure: closure,
-            name: name,
-            comments: comments,
-            scope: scope || code_object.scope,
-            visibility: visibility || code_object.visibility,
-            # @todo Might need to convert overloads to signatures
-            parameters: [],
-            explicit: code_object.is_explicit?,
-            return_type: return_type
-          )
-          pin.parameters.concat get_parameters(code_object, location, comments, pin)
+          final_scope = scope || code_object.scope
+          override_key = [closure.path, final_scope, name]
+          final_visibility = VISIBILITY_OVERRIDE[override_key]
+          final_visibility ||= VISIBILITY_OVERRIDE[[closure.path, final_scope]]
+          final_visibility ||= :private if closure.path == 'Kernel' && Kernel.private_instance_methods(false).include?(name.to_sym)
+          final_visibility ||= visibility
+          final_visibility ||= :private if code_object.module_function? && final_scope == :instance
+          final_visibility ||= :public if code_object.module_function? && final_scope == :class
+          final_visibility ||= code_object.visibility
+          if code_object.is_alias?
+            origin_code_object = code_object.namespace.aliases[code_object]
+            pin = Pin::MethodAlias.new(
+              name: name,
+              location: location,
+              original: origin_code_object.name.to_s,
+              closure: closure,
+              comments: comments,
+              scope: final_scope,
+              visibility: final_visibility,
+              explicit: code_object.is_explicit?,
+              return_type: return_type,
+              parameters: [],
+              source: :yardoc,
+            )
+          else
+            pin = Pin::Method.new(
+              location: location,
+              closure: closure,
+              name: name,
+              comments: comments,
+              scope: final_scope,
+              visibility: final_visibility,
+              # @todo Might need to convert overloads to signatures
+              explicit: code_object.is_explicit?,
+              return_type: return_type,
+              attribute: code_object.is_attribute?,
+              parameters: [],
+              source: :yardoc,
+            )
+            pin.parameters.concat get_parameters(code_object, location, comments, pin)
+            pin.parameters.freeze
+          end
+          logger.debug { "ToMethod.make: Just created method pin: #{pin.inspect}" }
           pin
         end
 
         class << self
+          include Logging
+
           private
 
           # @param code_object [YARD::CodeObjects::Base]
@@ -51,6 +85,7 @@ module Solargraph
             # HACK: Skip `nil` and `self` parameters that are sometimes emitted
             # for methods defined in C
             # See https://github.com/castwide/solargraph/issues/345
+            # @sg-ignore https://github.com/castwide/solargraph/pull/1114
             code_object.parameters.select { |a| a[0] && a[0] != 'self' }.map do |a|
               Solargraph::Pin::Parameter.new(
                 location: location,
@@ -59,7 +94,8 @@ module Solargraph
                 name: arg_name(a),
                 presence: nil,
                 decl: arg_type(a),
-                asgn_code: a[1]
+                asgn_code: a[1],
+                source: :yardoc,
               )
             end
           end

data/lib/solargraph/yard_map/mapper/to_namespace.rb

@@ -6,19 +6,23 @@ module Solargraph
       module ToNamespace
         extend YardMap::Helpers
 
+        # @param code_object [YARD::CodeObjects::NamespaceObject]
+        # @param spec [Gem::Specification, nil]
+        # @param closure [Pin::Closure, nil]
+        # @return [Pin::Namespace]
         def self.make code_object, spec, closure = nil
-          closure ||= Solargraph::Pin::Namespace.new(
-            name: code_object.namespace.to_s,
-            closure: Pin::ROOT_PIN,
-            gates: [code_object.namespace.to_s]
-          )
+          closure ||= create_closure_namespace_for(code_object, spec)
+          location = object_location(code_object, spec)
+
           Pin::Namespace.new(
-            location: object_location(code_object, spec),
+            location: location,
             name: code_object.name.to_s,
             comments: code_object.docstring ? code_object.docstring.all.to_s : '',
             type: code_object.is_a?(YARD::CodeObjects::ClassObject) ? :class : :module,
             visibility: code_object.visibility,
-            closure: closure
+            closure: closure,
+            gates: closure.gates,
+            source: :yardoc,
           )
         end
       end

data/lib/solargraph/yard_map/mapper.rb

@@ -12,6 +12,7 @@ module Solargraph
       def initialize code_objects, spec = nil
         @code_objects = code_objects
         @spec = spec
+        # @type [Array<Solargraph::Pin::Base>]
         @pins = []
         @namespace_pins = {}
       end
@@ -46,15 +47,16 @@ module Solargraph
             else
               code_object.superclass.to_s
             end
-            result.push Solargraph::Pin::Reference::Superclass.new(name: superclass, closure: nspin)
+            result.push Solargraph::Pin::Reference::Superclass.new(name: superclass, closure: nspin, source: :yard_map)
           end
           code_object.class_mixins.each do |m|
-            result.push Solargraph::Pin::Reference::Extend.new(closure: nspin, name: m.path)
+            result.push Solargraph::Pin::Reference::Extend.new(closure: nspin, name: m.path, source: :yard_map)
           end
           code_object.instance_mixins.each do |m|
             result.push Solargraph::Pin::Reference::Include.new(
               closure: nspin, # @todo Fix this
-              name: m.path
+              name: m.path,
+              source: :yard_map
             )
           end
         elsif code_object.is_a?(YARD::CodeObjects::MethodObject)

data/lib/solargraph/yard_map/to_method.rb

@@ -15,6 +15,7 @@ module Solargraph
           # HACK: Skip `nil` and `self` parameters that are sometimes emitted
           # for methods defined in C
           # See https://github.com/castwide/solargraph/issues/345
+          # @sg-ignore https://github.com/castwide/solargraph/pull/1114
           code_object.parameters.select { |a| a[0] && a[0] != 'self' }.map do |a|
             Solargraph::Pin::Parameter.new(
               location: location,
@@ -23,7 +24,8 @@ module Solargraph
               name: arg_name(a),
               presence: nil,
               decl: arg_type(a),
-              asgn_code: a[1]
+              asgn_code: a[1],
+              source: :yard_map
             )
           end
         end
@@ -56,7 +58,7 @@ module Solargraph
 
       include Helpers
 
-      # @param code_object [YARD::CodeObjects::Base]
+      # @param code_object [YARD::CodeObjects::MethodObject]
       # @param name [String, nil]
       # @param scope [Symbol, nil]
       # @param visibility [Symbol, nil]
@@ -78,7 +80,8 @@ module Solargraph
           scope: scope || code_object.scope,
           visibility: visibility || code_object.visibility,
           parameters: InnerMethods.get_parameters(code_object, location, comments),
-          explicit: code_object.is_explicit?
+          explicit: code_object.is_explicit?,
+          source: :yard_map
         )
       end
     end

data/lib/solargraph/yardoc.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'open3'
+
 module Solargraph
   # Methods for caching and loading YARD documentation for gems.
   #
@@ -9,15 +11,31 @@ module Solargraph
     # Build and cache a gem's yardoc and return the path. If the cache already
     # exists, do nothing and return the path.
     #
+    # @param yard_plugins [Array<String>] The names of YARD plugins to use.
     # @param gemspec [Gem::Specification]
     # @return [String] The path to the cached yardoc.
-    def cache(gemspec)
-      path = path_for(gemspec)
+    def cache(yard_plugins, gemspec)
+      path = PinCache.yardoc_path gemspec
       return path if cached?(gemspec)
 
+      unless Dir.exist? gemspec.gem_dir
+        # Can happen in at least some (old?) RubyGems versions when we
+        # have a gemspec describing a standard library like bundler.
+        #
+        # https://github.com/apiology/solargraph/actions/runs/17650140201/job/50158676842?pr=10
+        Solargraph.logger.info { "Bad info from gemspec - #{gemspec.gem_dir} does not exist" }
+        return path
+      end
+
       Solargraph.logger.info "Caching yardoc for #{gemspec.name} #{gemspec.version}"
-      Dir.chdir gemspec.gem_dir do
-        `yardoc --db #{path} --no-output --plugin solargraph`
+      cmd = "yardoc --db #{path} --no-output --plugin solargraph"
+      yard_plugins.each { |plugin| cmd << " --plugin #{plugin}" }
+      Solargraph.logger.debug { "Running: #{cmd}" }
+      # @todo set these up to run in parallel
+      stdout_and_stderr_str, status = Open3.capture2e(current_bundle_env_tweaks, cmd, chdir: gemspec.gem_dir)
+      unless status.success?
+        Solargraph.logger.warn { "YARD failed running #{cmd.inspect} in #{gemspec.gem_dir}" }
+        Solargraph.logger.info stdout_and_stderr_str
       end
       path
     end
@@ -26,16 +44,16 @@ module Solargraph
     #
     # @param gemspec [Gem::Specification]
     def cached?(gemspec)
-      yardoc = File.join(path_for(gemspec), 'complete')
+      yardoc = File.join(PinCache.yardoc_path(gemspec), 'complete')
       File.exist?(yardoc)
     end
 
-    # Get the absolute path for a cached gem yardoc.
+    # True if another process is currently building the yardoc cache.
     #
     # @param gemspec [Gem::Specification]
-    # @return [String]
-    def path_for(gemspec)
-      File.join(Solargraph::Cache.work_dir, 'gems', "#{gemspec.name}-#{gemspec.version}.yardoc")
+    def processing?(gemspec)
+      yardoc = File.join(PinCache.yardoc_path(gemspec), 'processing')
+      File.exist?(yardoc)
     end
 
     # Load a gem's yardoc and return its code objects.
@@ -45,8 +63,25 @@ module Solargraph
     # @param gemspec [Gem::Specification]
     # @return [Array<YARD::CodeObjects::Base>]
     def load!(gemspec)
-      YARD::Registry.load! path_for(gemspec)
+      YARD::Registry.load! PinCache.yardoc_path gemspec
       YARD::Registry.all
     end
+
+    # If the BUNDLE_GEMFILE environment variable is set, we need to
+    # make sure it's an absolute path, as we'll be changing
+    # directories.
+    #
+    # 'bundle exec' sets an absolute path here, but at least the
+    # overcommit gem does not, breaking on-the-fly documention with a
+    # spawned yardoc command from our current bundle
+    #
+    # @return [Hash{String => String}] a hash of environment variables to override
+    def current_bundle_env_tweaks
+      tweaks = {}
+      if ENV['BUNDLE_GEMFILE'] && !ENV['BUNDLE_GEMFILE'].empty?
+        tweaks['BUNDLE_GEMFILE'] = File.expand_path(ENV['BUNDLE_GEMFILE'])
+      end
+      tweaks
+    end
   end
 end

data/lib/solargraph.rb

@@ -2,6 +2,7 @@
 
 Encoding.default_external = 'UTF-8'
 
+require 'bundler'
 require 'set'
 require 'yard-solargraph'
 require 'solargraph/yard_tags'
@@ -42,15 +43,39 @@ module Solargraph
   autoload :Logging,          'solargraph/logging'
   autoload :TypeChecker,      'solargraph/type_checker'
   autoload :Environ,          'solargraph/environ'
+  autoload :Equality,         'solargraph/equality'
   autoload :Convention,       'solargraph/convention'
   autoload :Parser,           'solargraph/parser'
   autoload :RbsMap,           'solargraph/rbs_map'
   autoload :GemPins,          'solargraph/gem_pins'
-  autoload :Cache,            'solargraph/cache'
+  autoload :PinCache,         'solargraph/pin_cache'
 
   dir = File.dirname(__FILE__)
   VIEWS_PATH = File.join(dir, 'solargraph', 'views')
 
+  CHDIR_MUTEX = Mutex.new
+
+  # @param type [Symbol] Type of assert.
+  def self.asserts_on?(type)
+    if ENV['SOLARGRAPH_ASSERTS'].nil? || ENV['SOLARGRAPH_ASSERTS'].empty?
+      false
+    elsif ENV['SOLARGRAPH_ASSERTS'] == 'on'
+      true
+    else
+      logger.warn "Unrecognized SOLARGRAPH_ASSERTS value: #{ENV['SOLARGRAPH_ASSERTS']}"
+      false
+    end
+  end
+
+  # @param type [Symbol] The type of assertion to perform.
+  # @param msg [String, nil] An optional message to log
+  # @param block [Proc] A block that returns a message to log
+  # @return [void]
+  def self.assert_or_log(type, msg = nil, &block)
+    raise (msg || block.call) if asserts_on?(type) && ![:combine_with_visibility].include?(type)
+    logger.info msg, &block
+  end
+
   # A convenience method for Solargraph::Logging.logger.
   #
   # @return [Logger]
@@ -60,6 +85,11 @@ module Solargraph
 
   # A helper method that runs Bundler.with_unbundled_env or falls back to
   # Bundler.with_clean_env for earlier versions of Bundler.
+  #
+  # @generic T
+  # @yieldreturn [generic<T>]
+  # @sg-ignore dynamic call, but both functions behave the same
+  # @return [generic<T>]
   def self.with_clean_env &block
     meth = if Bundler.respond_to?(:with_original_env)
       :with_original_env
@@ -69,3 +99,7 @@ module Solargraph
     Bundler.send meth, &block
   end
 end
+
+# Ensure that ParserGem node processors are properly loaded to avoid conflicts
+# with Convention node processors
+require 'solargraph/parser/parser_gem/node_processors'