solargraph 0.32.5 → 0.33.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c99435136ad89666edbb8b132cd5715509cf0c7c365f1a0d3613db1579a718b
-  data.tar.gz: afc550f621504729249a88461a719d28440a5dc8dcc226a1bb99f87d6ae65b8d
+  metadata.gz: 158c70ae0a463e58b036390de759450ff08ef9021338fac799b572c2ca31c705
+  data.tar.gz: 5ff363662d8bca00cd0e66dc34845532d9d19e9812d5a04c6f9c8c18319ee609
 SHA512:
-  metadata.gz: a1396aec7a3ca2fb02a71d06a1c994f89c361c38cecdea08fde2d6cba02d73a824e1feca0d1ad886c59158fb52c4022d82e1e410847dbad85784e299e23c3b95
-  data.tar.gz: a6f1252139db4157a3a2fdb2a4322da06de9e16912cbd37c8450d51a921341071223fc10f24cf0e2d3798ba08e73c41dade0ccad20a704360ee2851640fc1e81
+  metadata.gz: dddd44984f04c8307e590cd96344dad5bf25e5765ca0a03d8de03028820ca7e58abc248d5dd9430ee9e6841de491f5a46a68a63f6b4db8b0508347fa2b3fd7b2
+  data.tar.gz: 9e394ad6f0558f8c194dd8efb667c58a3bc512ff65f98b11342e07270ed96f854a50904740b01bd23d0a4c31d4f944a82a8369a65802b1857425ea881a4d0058

data/.gitignore

@@ -7,3 +7,4 @@ Gemfile.lock
 doc
 coverage
 /tmp/
+guides

data/README.md

@@ -59,6 +59,8 @@ The gem includes an executable that provides access to the library's features. F
 The language server protocol is the recommended way for integrating Solargraph into editors and IDEs. Clients can connect using either stdio or TCP.
 See [LANGUAGE_SERVER.md](LANGUAGE_SERVER.md) for more information.
 
+## Updating Core Documentation
+
 The Solargraph gem ships with documentation for Ruby 2.2.2. As of gem version 0.15.0, there's an option to download additional documentation for other Ruby versions from the command line.
 
     $ solargraph list-cores      # List the installed documentation versions
@@ -78,17 +80,6 @@ Run `bundle install` and use `bundle exec yard gems` to generate the documentati
 
 In order to access the gems in your project, you'll need to start the language server with Bundler. In VS Code, there's a `solargraph.useBundler` option. Other clients will vary, but the command you probably want to run is `bundle exec solargraph socket` or `bundle exec solargraph stdio`.
 
-## Runtime Suggestions (EXPERIMENTAL)
-
-As of gem version 0.15.0, Solargraph includes experimental support for plugins.
-
-The Runtime plugin enhances code completion by querying namespaces for method names in a subprocess. If it finds any undocumented or "magic" methods, they get added to the suggestions.
-
-This feature is currently disabled by default. If you'd like to try it, you can enable it by setting the `plugins` section in your project's .solargraph.yml file:
-
-    plugins:
-    - runtime
-
 ## Contributing to Solargraph
 
 ### Bug Reports and Feature Requests

data/lib/solargraph.rb

@@ -23,9 +23,7 @@ module Solargraph
   autoload :ApiMap,           'solargraph/api_map'
   autoload :YardMap,          'solargraph/yard_map'
   autoload :Pin,              'solargraph/pin'
-  autoload :LiveMap,          'solargraph/live_map'
   autoload :ServerMethods,    'solargraph/server_methods'
-  autoload :Plugin,           'solargraph/plugin'
   autoload :CoreFills,        'solargraph/core_fills'
   autoload :LanguageServer,   'solargraph/language_server'
   autoload :Workspace,        'solargraph/workspace'
@@ -35,6 +33,7 @@ module Solargraph
   autoload :ComplexType,      'solargraph/complex_type'
   autoload :Bundle,           'solargraph/bundle'
   autoload :Logging,          'solargraph/logging'
+  autoload :TypeChecker,      'solargraph/type_checker'
 
   dir = File.dirname(__FILE__)
   YARDOC_PATH = File.realpath(File.join(dir, '..', 'yardoc'))

data/lib/solargraph/api_map.rb

@@ -13,21 +13,15 @@ module Solargraph
 
     include SourceToYard
 
-    # Get a LiveMap associated with the current workspace.
-    #
-    # @return [Solargraph::LiveMap]
-    attr_reader :live_map
-
     # @return [Array<String>]
     attr_reader :unresolved_requires
 
     # @param pins [Array<Solargraph::Pin::Base>]
     def initialize pins: []
-      # @todo Extensions don't work yet
-      # require_extensions
       @source_map_hash = {}
       @cache = Cache.new
       @mutex = Mutex.new
+      @method_alias_stack = []
       index pins
     end
 
@@ -40,7 +34,6 @@ module Solargraph
         @store = Store.new(pins + YardMap.new.pins)
         @unresolved_requires = []
       }
-      # resolve_method_aliases
       self
     end
 
@@ -97,12 +90,14 @@ module Solargraph
         reqs.concat map.requires.map(&:name)
       end
       reqs.concat bundle.workspace.config.required
+      local_path_hash.clear
       unless bundle.workspace.require_paths.empty?
         reqs.delete_if do |r|
           result = false
           bundle.workspace.require_paths.each do |l|
             pn = Pathname.new(bundle.workspace.directory).join(l, "#{r}.rb")
             if new_map_hash.keys.include?(pn.to_s)
+              local_path_hash[r] = pn.to_s
               result = true
               break
             end
@@ -118,10 +113,13 @@ module Solargraph
         @store = new_store
         @unresolved_requires = yard_map.unresolved_requires
       }
-      # resolve_method_aliases
       self
     end
 
+    def local_path_hash
+      @local_paths ||= {}
+    end
+
     # @param filename [String]
     # @param position [Position, Array(Integer, Integer)]
     # @return [Source::Cursor]
@@ -218,9 +216,7 @@ module Solargraph
     # @param context [String] The context to search
     # @return [String]
     def qualify namespace, context = ''
-      # @todo The return for self might work better elsewhere
-      return nil if namespace.nil?
-      return qualify(context) if namespace == 'self'
+      return namespace if ['self', nil].include?(namespace)
       cached = cache.get_qualified_namespace(namespace, context)
       return cached.clone unless cached.nil?
       result = if namespace.start_with?('::')
@@ -240,11 +236,13 @@ module Solargraph
     # @return [Array<Solargraph::Pin::InstanceVariable>]
     def get_instance_variable_pins(namespace, scope = :instance)
       result = []
+      used = [namespace]
       result.concat store.get_instance_variables(namespace, scope)
-      sc = qualify(store.get_superclass(namespace), namespace)
-      until sc.nil?
+      sc = qualify_lower(store.get_superclass(namespace), namespace)
+      until sc.nil? || used.include?(sc)
+        used.push sc
         result.concat store.get_instance_variables(sc, scope)
-        sc = qualify(store.get_superclass(sc), sc)
+        sc = qualify_lower(store.get_superclass(sc), sc)
       end
       result
     end
@@ -274,7 +272,7 @@ module Solargraph
     # @param scope [Symbol] :class or :instance
     # @param visibility [Array<Symbol>] :public, :protected, and/or :private
     # @param deep [Boolean] True to include superclasses, mixins, etc.
-    # @return [Array<Solargraph::Pin::Base>]
+    # @return [Array<Solargraph::Pin::BaseMethod>]
     def get_methods fqns, scope: :instance, visibility: [:public], deep: true
       cached = cache.get_methods(fqns, scope, visibility, deep)
       return cached.clone unless cached.nil?
@@ -292,12 +290,7 @@ module Solargraph
       else
         result.concat inner_get_methods(fqns, scope, visibility, deep, skip)
       end
-      # live = live_map.get_methods(fqns, '', scope.to_s, visibility.include?(:private))
-      # unless live.empty?
-      #   exist = result.map(&:name)
-      #   result.concat live.reject{|p| exist.include?(p.name)}
-      # end
-      resolved = resolve_method_aliases(result)
+      resolved = resolve_method_aliases(result, visibility)
       cache.set_methods(fqns, scope, visibility, deep, resolved)
       resolved
     end
@@ -327,7 +320,7 @@ module Solargraph
       result = []
       if type.duck_type?
         type.select(&:duck_type?).each do |t|
-          result.push Pin::DuckMethod.new(nil, t.tag[1..-1])
+          result.push Pin::DuckMethod.new(name: t.tag[1..-1])
         end
         result.concat get_methods('Object')
       else
@@ -354,7 +347,7 @@ module Solargraph
     # @param fqns [String]
     # @param name [String]
     # @param scope [Symbol] :instance or :class
-    # @return [Array<Solargraph::Pin::Base>]
+    # @return [Array<Solargraph::Pin::BaseMethod>]
     def get_method_stack fqns, name, scope: :instance
       get_methods(fqns, scope: scope, visibility: [:private, :protected, :public]).select{|p| p.name == name}
     end
@@ -369,10 +362,6 @@ module Solargraph
       return [] if path.nil?
       result = []
       result.concat store.get_path_pins(path)
-      # if result.empty?
-      #   lp = live_map.get_path_pin(path)
-      #   result.push lp unless lp.nil?
-      # end
       resolve_method_aliases(result)
     end
 
@@ -452,6 +441,11 @@ module Solargraph
       source_map_hash[filename].document_symbols
     end
 
+    # @return [Array<SourceMap>]
+    def source_maps
+      source_map_hash.values
+    end
+
     # Get a source map by filename.
     #
     # @param filename [String]
@@ -461,6 +455,42 @@ module Solargraph
       source_map_hash[filename]
     end
 
+    # True if the specified file was included in a bundle, i.e., it's either
+    # included in a workspace or open in a library.
+    #
+    # @param filename [String]
+    def bundled? filename
+      source_map_hash.keys.include?(filename)
+    end
+
+    # @param location [Location]
+    def require_reference_at location
+      map = source_map(location.filename)
+      pin = map.requires.select { |pin| pin.location.range.contain?(location.range.start) }.first
+      return nil if pin.nil?
+      if local_path_hash.key?(pin.name)
+        return Location.new(local_path_hash[pin.name], Solargraph::Range.from_to(0, 0, 0, 0))
+      end
+      yard_map.require_reference(pin.name)
+    rescue FileNotFoundError
+      nil
+    end
+
+    # Check if a class is a superclass of another class.
+    #
+    # @param sup [String] The superclass
+    # @param sub [String] The subclass
+    # @return [Boolean]
+    def super_and_sub?(sup, sub)
+      fqsup = qualify(sup)
+      cls = qualify(store.get_superclass(sub), sub)
+      until cls.nil?
+        return true if cls == fqsup
+        cls = qualify(store.get_superclass(cls), cls)
+      end
+      false
+    end
+
     private
 
     # @return [YardMap]
@@ -544,27 +574,21 @@ module Solargraph
         fqis = qualify(is, fqns)
         result.concat inner_get_constants(fqis, [:public], skip) unless fqis.nil?
       end
-      # result.concat live_map.get_constants(fqns)
       result
     end
 
-    # Require extensions for the experimental plugin architecture. Any
-    # installed gem with a name that starts with "solargraph-" is considered
-    # an extension.
-    #
-    # @return [void]
-    def require_extensions
-      Gem::Specification.all_names.select{|n| n.match(/^solargraph\-[a-z0-9_\-]*?\-ext\-[0-9\.]*$/)}.each do |n|
-        Solargraph::Logging.logger.info "Loading extension #{n}"
-        require n.match(/^(solargraph\-[a-z0-9_\-]*?\-ext)\-[0-9\.]*$/)[1]
-      end
-    end
-
     # @return [Hash]
     def path_macros
       @path_macros ||= {}
     end
 
+    # @param namespace [String]
+    # @param context [String]
+    # @return [String]
+    def qualify_lower namespace, context
+      qualify namespace, context.split('::')[0..-2].join('::')
+    end
+
     # @param name [String]
     # @param root [String]
     # @param skip [Array<String>]
@@ -599,7 +623,6 @@ module Solargraph
         end
         return name if store.namespace_exists?(name)
       end
-      # live_map.get_fqns(name, root)
     end
 
     # Get the namespace's type (Class or Module).
@@ -608,6 +631,7 @@ module Solargraph
     # @return [Symbol] :class, :module, or nil
     def get_namespace_type fqns
       return nil if fqns.nil?
+      # @type [Pin::Namespace, nil]
       pin = store.get_path_pins(fqns).select{|p| p.is_a?(Pin::Namespace)}.first
       return nil if pin.nil?
       pin.type
@@ -630,30 +654,36 @@ module Solargraph
       result + nil_pins
     end
 
-    # Check if a class is a superclass of another class.
-    #
-    # @param sup [String] The superclass
-    # @param sub [String] The subclass
-    # @return [Boolean]
-    def super_and_sub?(sup, sub)
-      fqsup = qualify(sup)
-      cls = qualify(store.get_superclass(sub), sub)
-      until cls.nil?
-        return true if cls == fqsup
-        cls = qualify(store.get_superclass(cls), cls)
-      end
-      false
-    end
-
     # @param pins [Array<Pin::Base>]
+    # @param visibility [Array<Symbol>]
     # @return [Array<Pin::Base>]
-    def resolve_method_aliases pins
-      pins.map do |pin|
-        next pin unless pin.kind == Pin::METHOD_ALIAS
-        origin = get_method_stack(pin.namespace, pin.original, scope: pin.scope).select{|pin| pin.is_a?(Pin::BaseMethod)}.first
-        next pin if origin.nil?
-        Pin::Method.new(pin.location, pin.namespace, pin.name, origin.comments, origin.scope, origin.visibility, origin.parameters)
+    def resolve_method_aliases pins, visibility = [:public, :private, :protected]
+      result = []
+      pins.each do |pin|
+        resolved = resolve_method_alias(pin)
+        next unless visibility.include?(resolved.visibility)
+        result.push resolved
       end
+      result
+    end
+
+    # @param pin [Pin::MethodAlias, Pin::Base]
+    # @return [Pin::BaseMethod]
+    def resolve_method_alias pin
+      return pin if !pin.is_a?(Pin::MethodAlias) || @method_alias_stack.include?(pin.path)
+      @method_alias_stack.push pin.path
+      origin = get_method_stack(pin.full_context.namespace, pin.original, scope: pin.scope).first
+      @method_alias_stack.pop
+      return pin if origin.nil?
+      Pin::Method.new(
+        location: pin.location,
+        closure: pin.closure,
+        name: pin.name,
+        comments: origin.comments,
+        scope: origin.scope,
+        visibility: origin.visibility,
+        args: origin.parameters
+      )
     end
   end
 end

data/lib/solargraph/api_map/cache.rb

@@ -5,6 +5,7 @@ module Solargraph
         @methods = {}
         @constants = {}
         @qualified_namespaces = {}
+        @receiver_definitions = {}
       end
 
       def get_methods fqns, scope, visibility, deep
@@ -31,18 +32,32 @@ module Solargraph
         @qualified_namespaces[[name, context]] = value
       end
 
+      def receiver_defined? path
+        @receiver_definitions.key? path
+      end
+
+      def get_receiver_definition path
+        @receiver_definitions[path]
+      end
+
+      def set_receiver_definition path, pin
+        @receiver_definitions[path] = pin
+      end
+
       # @return [void]
       def clear
         @methods.clear
         @constants.clear
         @qualified_namespaces.clear
+        @receiver_definitions.clear
       end
 
       # @return [Boolean]
       def empty?
         @methods.empty? &&
           @constants.empty? &&
-          @qualified_namespaces.empty?
+          @qualified_namespaces.empty? &&
+          @receiver_definitions.empty?
       end
     end
   end

data/lib/solargraph/api_map/source_to_yard.rb

@@ -15,31 +15,40 @@ module Solargraph
         code_object_map.keys
       end
 
-      # @param store [Array<Store>] ApiMap pin store
+      # @param store [ApiMap::Store] ApiMap pin store
       # @return [void]
       def rake_yard store
         code_object_map.clear
         store.namespace_pins.each do |pin|
           next if pin.path.nil? or pin.path.empty?
+          if pin.code_object
+            code_object_map[pin.path] ||= pin.code_object
+            next
+          end
           if pin.type == :class
             code_object_map[pin.path] ||= YARD::CodeObjects::ClassObject.new(root_code_object, pin.path)
           else
             code_object_map[pin.path] ||= YARD::CodeObjects::ModuleObject.new(root_code_object, pin.path)
           end
           code_object_map[pin.path].docstring = pin.docstring
-          code_object_map[pin.path].files.push pin.location.filename unless pin.location.nil?
-        end
-        store.namespace_pins.each do |pin|
-          # pin.include_references.each do |ref|
+          code_object_map[pin.path].files.push pin.location.filename unless pin.location.nil? || code_object_map[pin.path].files.include?(pin.location.filename)
           store.get_includes(pin.path).each do |ref|
             code_object_map[pin.path].instance_mixins.push code_object_map[ref] unless code_object_map[ref].nil? or code_object_map[pin.path].nil?
           end
+          store.get_extends(pin.path).each do |ref|
+            code_object_map[pin.path].instance_mixins.push code_object_map[ref] unless code_object_map[ref].nil? or code_object_map[pin.path].nil?
+            code_object_map[pin.path].class_mixins.push code_object_map[ref] unless code_object_map[ref].nil? or code_object_map[pin.path].nil?
+          end
         end
         store.method_pins.each do |pin|
+          if pin.code_object
+            code_object_map[pin.path] ||= pin.code_object
+            next
+          end
           code_object_map[pin.path] ||= YARD::CodeObjects::MethodObject.new(code_object_at(pin.namespace), pin.name, pin.scope)
           code_object_map[pin.path].docstring = pin.docstring
           code_object_map[pin.path].visibility = pin.visibility || :public
-          code_object_map[pin.path].files.push pin.location.filename unless pin.location.nil?
+          code_object_map[pin.path].files.push pin.location.filename unless pin.location.nil? || code_object_map[pin.path].files.include?(pin.location.filename)
           code_object_map[pin.path].parameters = pin.parameters.map do |p|
             n = p.match(/^[a-z0-9_]*:?/i)[0]
             v = nil
@@ -53,7 +62,7 @@ module Solargraph
 
       private
 
-      # @return [Hash]
+      # @return [Hash{String => YARD::CodeObjects::Base}]
       def code_object_map
         @code_object_map ||= {}
       end