solargraph 0.25.1 → 0.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2bd332c0e24354eee990335169e5d861e470714cf3f3431b41c5d7e184f33035
-  data.tar.gz: a4ce050c8e2e9ef1990c9be69dc2a4a6457cf27bc9b7ba85168014c30da77480
+  metadata.gz: 6faf5ac32f43c83b6d510ed61cac764185616fc4420198ed7adf6b9285ce7d77
+  data.tar.gz: 4d7a0abf2e8dd321dbefc90932766c97167caad8291739ed4ca4dc1537ea381e
 SHA512:
-  metadata.gz: 9cd5cfb006e654069b88c596dea33d6be250bda7569a1193c834336345fa927d0b28b48fdfa5c37f68f3ce56ffc6cf6e647cda4e6184cbb566e8ad68ef3ac339
-  data.tar.gz: 9846d874b79d01132a0fdb8ad7dd6f0cf81682a1fb9e1f3d72602d8ca3330380fba455f9c4d7f9e624bb40b2dff21d39fcef42c4273832c549b296c4a98b4a24
+  metadata.gz: '08ea817581e66ecc51b4cb19ccb2f5fa7dbb414375b3c1461ce680fa5c382ff2faa46da58e4a297c8a81ffd5782cb6aef9a8eecd74b8804f0e2c6addd56205d6'
+  data.tar.gz: 73f36e26202c49869b8afcf4cfd77971f3614863e74dd8f5f6c386fe5fa5d844e62e2995ffa198b4468645577d936b97c4bbf9fdab65b0a8956c95036acfee2b

data/lib/solargraph.rb

@@ -24,21 +24,23 @@ module Solargraph
     end
   end
 
-  autoload :Shell,          'solargraph/shell'
-  autoload :Source,         'solargraph/source'
-  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'
-  autoload :Page,           'solargraph/page'
-  autoload :Library,        'solargraph/library'
-  autoload :Diagnostics,    'solargraph/diagnostics'
-  autoload :ComplexType,    'solargraph/complex_type'
+  autoload :Shell,            'solargraph/shell'
+  autoload :Source,           'solargraph/source'
+  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'
+  autoload :Page,             'solargraph/page'
+  autoload :Library,          'solargraph/library'
+  autoload :Diagnostics,      'solargraph/diagnostics'
+  autoload :BasicTypeMethods, 'solargraph/basic_type_methods'
+  autoload :BasicType,        'solargraph/basic_type'
+  autoload :ComplexType,      'solargraph/complex_type'
 
   YARDOC_PATH = File.join(File.realpath(File.dirname(__FILE__)), '..', 'yardoc')
   YARD_EXTENSION_FILE = File.join(File.realpath(File.dirname(__FILE__)), 'yard-solargraph.rb')
@@ -47,4 +49,4 @@ end
 
 Solargraph::YardMap::CoreDocs.require_minimum
 # Change YARD log IO to avoid sending unexpected messages to STDOUT
-YARD::Logger.instance.io = STDERR
+YARD::Logger.instance.io = File.new(File::NULL, 'w')

data/lib/solargraph/api_map.rb

@@ -9,14 +9,10 @@ module Solargraph
   class ApiMap
     autoload :Cache,        'solargraph/api_map/cache'
     autoload :SourceToYard, 'solargraph/api_map/source_to_yard'
-    autoload :Completion,   'solargraph/api_map/completion'
-    autoload :Probe,        'solargraph/api_map/probe'
     autoload :Store,        'solargraph/api_map/store'
-    autoload :TypeMethods,  'solargraph/api_map/type_methods'
 
     include Solargraph::ApiMap::SourceToYard
     include CoreFills
-    include TypeMethods
 
     # The workspace to analyze and process.
     #
@@ -141,7 +137,7 @@ module Solargraph
     #
     # @return [Array<Solargraph::Pin::Keyword>]
     def self.keywords
-      @keyword_suggestions ||= KEYWORDS.map{ |s|
+      @keywords ||= KEYWORDS.map{ |s|
         Pin::Keyword.new(s)
       }.freeze
     end
@@ -207,6 +203,13 @@ module Solargraph
       result
     end
 
+    def fragment_at(location)
+      @sources.each do |source|
+        return source.fragment_at(location.range.start.line, location.range.start.column) if source.filename == location.filename
+      end
+      nil
+    end
+
     # @deprecated Use #qualify instead
     # @param namespace [String]
     # @param context [String]
@@ -238,6 +241,14 @@ module Solargraph
       store.get_symbols
     end
 
+    # @todo Make this better
+    def get_source filename
+      @sources.each do |s|
+        return s if s.filename == filename
+      end
+      nil
+    end
+
     # @return [Array<Solargraph::Pin::GlobalVariable>]
     def get_global_variable_pins
       globals = []
@@ -261,8 +272,8 @@ module Solargraph
       skip = []
       if fqns == ''
         domains.each do |domain|
-          namespace, scope = extract_namespace_and_scope(domain)
-          result.concat inner_get_methods(namespace, scope, [:public], deep, skip)
+          type = ComplexType.parse(domain).first
+          result.concat inner_get_methods(type.name, type.scope, [:public], deep, skip)
         end
         result.concat inner_get_methods(fqns, :class, visibility, deep, skip)
         result.concat inner_get_methods(fqns, :instance, visibility, deep, skip)
@@ -279,140 +290,55 @@ module Solargraph
       result
     end
 
-    # Get a stack of method pins for a method name in a namespace. The order
-    # of the pins corresponds to the ancestry chain, with highest precedence
-    # first.
+    # Get an array of public methods for a complex type.
     #
-    # @param fqns [String]
-    # @param name [String]
-    # @param scope [Symbol] :instance or :class
+    # @param type [Solargraph::ComplexType]
+    # @param context [String]
     # @return [Array<Solargraph::Pin::Base>]
-    def get_method_stack fqns, name, scope: :instance
-      # cached = cache.get_method_stack(fqns, name, scope)
-      # return cached.clone unless cached.nil?
-      result = get_methods(fqns, scope: scope, visibility: [:private, :protected, :public]).select{|p| p.name == name}
-      # cache.set_method_stack(fqns, name, scope, result)
-      result
-    end
-
-    # Get a set of available completions for the specified fragment. The
-    # resulting Completion object contains an array of pins and the range of
-    # text to replace in the source.
-    #
-    # @param fragment [Solargraph::Source::Fragment]
-    # @return [ApiMap::Completion]
-    def complete fragment
-      return Completion.new([], fragment.whole_word_range) if fragment.string? or fragment.comment?
+    def get_complex_type_methods type, context = '', internal = false
+      return [] if type.undefined? or type.void?
       result = []
-      if !fragment.signature.include?('.') and !fragment.base_literal?
-        if fragment.signature.start_with?('@@')
-          result.concat get_class_variable_pins(fragment.namespace)
-        elsif fragment.signature.start_with?('@')
-          result.concat get_instance_variable_pins(fragment.namespace, fragment.scope)
-        elsif fragment.signature.start_with?('$')
-          result.concat get_global_variable_pins
-        elsif fragment.signature.start_with?(':') and !fragment.signature.start_with?('::')
-          result.concat get_symbols
-        else
-          unless fragment.signature.include?('::')
-            result.concat prefer_non_nil_variables(fragment.locals)
-            result.concat get_methods(fragment.namespace, scope: fragment.scope, visibility: [:public, :private, :protected])
-            result.concat get_methods('Kernel')
-            result.concat ApiMap.keywords
-          end
-          result.concat get_constants(fragment.base, fragment.namespace)
+      if type.duck_type?
+        type.select(&:duck_type?).each do |t|
+          result.push Pin::DuckMethod.new(nil, t.tag[1..-1])
         end
       else
-        if fragment.base_literal?
-          pin = get_path_suggestions(fragment.base_literal).select{|pin| pin.kind == Pin::NAMESPACE}.first
-          unless pin.nil?
-            if fragment.base.empty?
-              result.concat get_methods(pin.path)
-            else
-              type = probe.infer_signature_type("#{pin.path}.new.#{fragment.base}", pin, fragment.locals)
-              unless type.nil?
-                namespace, scope = extract_namespace_and_scope(type)
-                result.concat get_methods(namespace, scope: scope)
-              end
-            end
+        unless type.nil? or type.name == 'void'
+          namespace = qualify(type.namespace, context)
+          if ['Class', 'Module'].include?(namespace) and !type.subtypes.empty?
+            subtype = qualify(type.subtypes.first.name, context)
+            result.concat get_methods(subtype, scope: :class)
           end
-        elsif fragment.signature.include?('::') and !fragment.signature.include?('.')
-          result.concat get_constants(fragment.base, fragment.namespace)
-        else
-          pins = probe.infer_signature_pins(fragment.base, fragment.named_path, fragment.locals)
-          unless pins.empty?
-            pin = pins.first
-            if pin.variable? and pin.return_type.nil? and !pin.signature.nil?
-              type = probe.infer_signature_type(pin.signature, pin.context, fragment.locals)
-              result.concat(get_methods(type)) unless type.nil?
-            elsif pin.return_complex_types.any? and pin.return_complex_types.first.duck_type?
-              pin.return_complex_types.each do |t|
-                next unless t.duck_type?
-                result.push Pin::DuckMethod.new(pin.location, t.tag[1..-1])
-              end
-              result.concat(get_methods('Object', scope: :instance))
-            end
-            if result.empty?
-              pins.each do |pin|
-                type = pin.return_type
-                unless type.nil? or type == 'void'
-                  docns, scope = extract_namespace_and_scope(type)
-                  namespace = qualify(docns, pin.namespace)
-                  result.concat get_methods(namespace, scope: scope)
-                  break
-                end
-              end
-            end
+          visibility = [:public]
+          if namespace == context or super_and_sub?(namespace, context)
+            visibility.push :protected
+            visibility.push :private if internal
           end
+          result.concat get_methods(namespace, scope: type.scope, visibility: visibility)
         end
       end
-      frag_start = fragment.word.to_s.downcase
-      filtered = result.uniq(&:identifier).select{|s| s.name.downcase.start_with?(frag_start) and (s.kind != Pin::METHOD or s.name.match(/^[a-z0-9_]+(\!|\?|=)?$/i))}.sort_by.with_index{ |x, idx| [x.name, idx] }
-      Completion.new(filtered, fragment.whole_word_range)
-    end
-
-    # Get an array of pins that describe the symbol at the specified fragment.
-    #
-    # @param fragment [Solargraph::Source::Fragment]
-    # @return [Array<Solargraph::Pin::Base>]
-    def define fragment
-      return get_path_suggestions(fragment.namespace) if fragment.whole_signature == 'self'
-      return [] if fragment.string? or fragment.comment? or fragment.literal? or KEYWORDS.include?(fragment.whole_signature)
-      if fragment.base_literal?
-        probe.infer_signature_pins fragment.whole_signature, Pin::ProxyMethod.new(fragment.base_literal), fragment.locals
-      else
-        probe.infer_signature_pins fragment.whole_signature, fragment.named_path, fragment.locals
-      end
-    end
-
-    # Infer a return type from a fragment. This method will attempt to resolve
-    # signatures.
-    #
-    # @param fragment [Solargraph::Source::Fragment]
-    # @return [String]
-    def infer_type fragment
-      return nil if fragment.string? or fragment.comment?
-      probe.infer_signature_type fragment.whole_signature, fragment.named_path, fragment.locals
+      result
     end
 
-    # Get an array of pins that describe the method being called by the
-    # argument list where the fragment is located. This is useful for queries
-    # that need to know what parameters the current method expects to receive.
+    # Get a stack of method pins for a method name in a namespace. The order
+    # of the pins corresponds to the ancestry chain, with highest precedence
+    # first.
     #
-    # If the fragment is not inside an argument list, return an empty array.
+    # @example
+    #   api_map.get_method_stack('Subclass', 'method_name')
+    #     #=> [ <Subclass#method_name pin>, <Superclass#method_name pin> ]
     #
-    # @param fragment [Solargraph::Source::Fragment]
+    # @param fqns [String]
+    # @param name [String]
+    # @param scope [Symbol] :instance or :class
     # @return [Array<Solargraph::Pin::Base>]
-    def signify fragment
-      return [] unless fragment.argument?
-      return [] if fragment.recipient.whole_signature.nil? or fragment.recipient.whole_signature.empty?
-      result = []
-      if fragment.recipient.base_literal?
-        result.concat probe.infer_signature_pins(fragment.recipient.whole_signature, Pin::ProxyMethod.new(fragment.recipient.base_literal), fragment.locals)
-      else
-        result.concat probe.infer_signature_pins(fragment.recipient.whole_signature, fragment.named_path, fragment.locals)
-      end
-      result.select{ |pin| pin.kind == Pin::METHOD }
+    def get_method_stack fqns, name, scope: :instance
+      # @todo Caches don't work on this query
+      # cached = cache.get_method_stack(fqns, name, scope)
+      # return cached.clone unless cached.nil?
+      result = get_methods(fqns, scope: scope, visibility: [:private, :protected, :public]).select{|p| p.name == name}
+      # cache.set_method_stack(fqns, name, scope, result)
+      result
     end
 
     # Get an array of all suggestions that match the specified path.
@@ -423,7 +349,6 @@ module Solargraph
       return [] if path.nil?
       result = []
       result.concat store.get_path_pins(path)
-      # result.concat yard_map.objects(path)
       if result.empty?
         lp = live_map.get_path_pin(path)
         result.push lp unless lp.nil?
@@ -439,7 +364,7 @@ module Solargraph
     # @param query [String] The text to match
     # @return [Array<String>]
     def search query
-      rake_yard(@sources) if @yard_stale
+      rake_yard(store) if @yard_stale
       @yard_stale = false
       found = []
       code_object_paths.each do |k|
@@ -458,11 +383,10 @@ module Solargraph
     # @param path [String] The path to find
     # @return [Array<YARD::CodeObject::Base>]
     def document path
-      rake_yard(@sources) if @yard_stale
+      rake_yard(store) if @yard_stale
       @yard_stale = false
       docs = []
       docs.push code_object_at(path) unless code_object_at(path).nil?
-      # docs.concat yard_map.document(path)
       docs
     end
 
@@ -483,20 +407,13 @@ module Solargraph
     def locate_pin location
       @sources.each do |source|
         pin = source.locate_pin(location)
-        unless pin.nil?
-          return pin
-        end
+        return pin unless pin.nil?
       end
       nil
     end
 
-    # @return [Probe]
-    def probe
-      @probe ||= Probe.new(self)
-    end
-
+    # @return [Array<String>]
     def unresolved_requires
-      # return [] if yard_map_changed?
       yard_map.unresolved_requires
     end
 
@@ -549,6 +466,12 @@ module Solargraph
       @cache ||= Cache.new
     end
 
+    # @param fqns [String] A fully qualified namespace
+    # @param scope [Symbol] :class or :instance
+    # @param visibility [Array<Symbol>] :public, :protected, and/or :private
+    # @param deep [Boolean]
+    # @param skip [Array<String>]
+    # @return [Array<Pin::Base>]
     def inner_get_methods fqns, scope, visibility, deep, skip
       reqstr = "#{fqns}|#{scope}|#{visibility.sort}|#{deep}"
       return [] if skip.include?(reqstr)
@@ -560,23 +483,19 @@ module Solargraph
         sc = store.get_superclass(fqns)
         unless sc.nil?
           fqsc = qualify(sc, fqns)
-          sc_visi = [:public]
-          sc_visi.push :protected if visibility.include?(:protected)
-          result.concat inner_get_methods(fqsc, scope, sc_visi, true, skip) unless fqsc.nil?
+          result.concat inner_get_methods(fqsc, scope, visibility, true, skip) unless fqsc.nil?
         end
         if scope == :instance
           store.get_includes(fqns).each do |im|
             fqim = qualify(im, fqns)
             result.concat inner_get_methods(fqim, scope, visibility, deep, skip) unless fqim.nil?
           end
-          # result.concat yard_map.get_instance_methods(fqns, visibility: visibility)
           result.concat inner_get_methods('Object', :instance, [:public], deep, skip) unless fqns == 'Object'
         else
           store.get_extends(fqns).each do |em|
             fqem = qualify(em, fqns)
             result.concat inner_get_methods(fqem, :instance, visibility, deep, skip) unless fqem.nil?
           end
-          # result.concat yard_map.get_methods(fqns, '', visibility: visibility)
           type = get_namespace_type(fqns)
           result.concat inner_get_methods('Class', :instance, fqns == '' ? [:public] : visibility, deep, skip) if type == :class
           result.concat inner_get_methods('Module', :instance, fqns == '' ? [:public] : visibility, deep, skip) #if type == :module
@@ -585,12 +504,15 @@ module Solargraph
       result
     end
 
+    # @param fqns [String]
+    # @param visibility [Array<Symbol>]
+    # @param skip [Array<String>]
+    # @return [Array<Pin::Base>]
     def inner_get_constants fqns, visibility, skip
       return [] if skip.include?(fqns)
       skip.push fqns
       result = []
       result.concat store.get_constants(fqns, visibility)
-      # result.concat yard_map.get_constants(fqns)
       store.get_includes(fqns).each do |is|
         fqis = qualify(is, fqns)
         result.concat inner_get_constants(fqis, [:public], skip) unless fqis.nil?
@@ -603,6 +525,7 @@ module Solargraph
     # 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|
         STDERR.puts "Loading extension #{n}"
@@ -610,20 +533,6 @@ module Solargraph
       end
     end
 
-    # @return [Array<Solargraph::Pin::Base>]
-    def prefer_non_nil_variables pins
-      result = []
-      nil_pins = []
-      pins.each do |pin|
-        if pin.variable? and pin.nil_assignment?
-          nil_pins.push pin
-        else
-          result.push pin
-        end
-      end
-      result + nil_pins
-    end
-
     # @return [Hash]
     def path_macros
       @path_macros ||= {}
@@ -634,6 +543,9 @@ module Solargraph
       @sources - [@virtual_source]
     end
 
+    # @param name [String]
+    # @param root [String]
+    # @param skip [Array<String>]
     # @return [String]
     def inner_qualify name, root, skip
       return nil if name.nil?
@@ -664,9 +576,10 @@ module Solargraph
 
     # Get the namespace's type (Class or Module).
     #
-    # @param [String] A fully qualified namespace
+    # @param fqns [String] A fully qualified namespace
     # @return [Symbol] :class, :module, or nil
     def get_namespace_type fqns
+      return nil if fqns.nil?
       pin = store.get_path_pins(fqns).first
       return nil if pin.nil?
       pin.type
@@ -678,5 +591,31 @@ module Solargraph
     def yard_map
       @yard_map ||= Solargraph::YardMap.new(required: required, workspace: workspace)
     end
+
+    # Sort an array of pins to put nil or undefined variables last.
+    #
+    # @param pins [Array<Solargraph::Pin::Base>]
+    # @return [Array<Solargraph::Pin::Base>]
+    def prefer_non_nil_variables pins
+      result = []
+      nil_pins = []
+      pins.each do |pin|
+        if pin.variable? and pin.nil_assignment?
+          nil_pins.push pin
+        else
+          result.push pin
+        end
+      end
+      result + nil_pins
+    end
+
+    def super_and_sub?(sup, sub)
+      cls = store.get_superclass(sub)
+      until cls.nil?
+        return true if cls == sup
+        cls = store.get_superclass(cls)
+      end
+      false
+    end
   end
 end