solargraph 0.18.3 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 249d94c36b0d3d32bd9c7d06933aa5b886b3c73e
-  data.tar.gz: 7229efdede3aee37cca5da7ed160f378c5cee95e
+  metadata.gz: 7584a4d20d5562279e2e86887fe56a448776ba91
+  data.tar.gz: bd353cd7bf5140f80f0a53155bfc03cb0dc1d73b
 SHA512:
-  metadata.gz: d46fb7bbec935080b31fe33d9219c5189c0a5d475e4be2329bed3ac502f0a195b6c320438470289aaacc643086f213a472cd38408e168ce20fc29b33225593d2
-  data.tar.gz: 5023b4965a27c1e60f52537ee8a2cc72eafbde90eab78f7bbbd3d71dff412034d86f4f53b638d74a7542357024e8d12943b71b1797e02de10573922a03178e05
+  metadata.gz: eb78c3e91842800f4646fc5c9f96371914226c17a6b3350b1bf4f5ec2e4e9b00801fa39034b52c859ee63613abef3d453aa87d0a18235e6bcb1093d62573de1a
+  data.tar.gz: 4cef990fe1e4935f478cac2a4b24067ca668f2c83de44ffb9d09e5b3faf46179ef4c2ec9fccd88681f07a4921fb58b6d2dba1ce06fb500e04ac9ab77522e71ee

data/lib/solargraph/api_map/probe.rb

@@ -0,0 +1,222 @@
+module Solargraph
+  class ApiMap
+    class Probe
+      class VirtualPin
+        attr_reader :return_type
+        def initialize return_type
+          @return_type = return_type
+        end
+      end
+
+      # @return [Solargraph::ApiMap]
+      attr_reader :api_map
+
+      def initialize api_map
+        @api_map = api_map
+      end
+
+      # Get all matching pins for the signature.
+      #
+      # @return [Array<Pin::Base>]
+      def infer_signature_pins signature, context_pin, locals
+        return [] if signature.nil? or signature.empty?
+        base, rest = signature.split('.', 2)
+        return infer_word_pins(base, context_pin, locals) if rest.nil?
+        pins = infer_word_pins(base, context_pin, locals).map do |pin|
+          next pin unless pin.return_type.nil?
+          type = resolve_pin_type(pin)
+          VirtualPin.new(type)
+        end
+        return [] if pins.empty?
+        rest = rest.split('.')
+        last = rest.pop
+        rest.each do |meth|
+          found = nil
+          pins.each do |pin|
+            found = infer_method_name_pins(meth, pin)
+            next if found.empty?
+            pins = found
+            break
+          end
+          return [] if found.nil?
+        end
+        pins.each do |pin|
+          found = infer_method_name_pins(last, pin)
+          return found unless found.empty?
+        end
+        []
+      end
+
+      # Get the return type for the signature.
+      #
+      # @return [String]
+      def infer_signature_type signature, context_pin, locals
+        pins = infer_signature_pins(signature, context_pin, locals)
+        pins.each do |pin|
+          type = resolve_pin_type(pin)
+          return qualify(type, pin.named_context) unless type.nil?
+        end
+        nil
+      end
+
+      private
+
+      # Word search is ALWAYS internal
+      def infer_word_pins word, context_pin, locals
+        return [] if word.empty?
+        lvars = locals.select{|pin| pin.name == word}
+        return lvars unless lvars.empty?
+        namespace, scope = extract_namespace_and_scope_from_pin(context_pin)
+        return api_map.pins.select{|pin| word_matches_context?(word, namespace, scope, pin)} if variable_name?(word)
+        result = []
+        result.concat api_map.get_path_suggestions(word)
+        result.concat api_map.get_methods(namespace, scope: scope, visibility: [:public, :private, :protected]).select{|pin| pin.name == word} unless word.include?('::')
+        result.concat api_map.get_constants('', namespace).select{|pin| pin.name == word}
+        result
+      end
+
+      # Method name search is external by default
+      def infer_method_name_pins method_name, context_pin, internal = false
+        namespace, scope = extract_namespace_and_scope(context_pin.return_type)
+        visibility = [:public]
+        visibility.push :protected, :private if internal
+        result = api_map.get_methods(namespace, scope: scope, visibility: visibility).select{|pin| pin.name == method_name}
+        # @todo This needs more rules. Probably need to update YardObject for it.
+        return result if result.empty?
+        return result unless method_name == 'new' and result.first.path == 'Class#new'
+        result.unshift virtual_new_pin(result.first, context_pin)
+        result
+      end
+
+      # Word and context matching rules for ApiMap source pins.
+      #
+      # @return [Boolean]
+      def word_matches_context? word, namespace, scope, pin
+        return false unless word == pin.name
+        return true if pin.kind == Pin::NAMESPACE and pin.path == namespace and scope == :class
+        return true if pin.kind == Pin::METHOD and pin.namespace == namespace and pin.scope == scope
+        # @todo Handle instance variables, class variables, etc. in various ways
+        pin.namespace == namespace and pin.scope == scope
+      end
+
+      # Fully qualify the namespace in a type.
+      #
+      # @return [String]
+      def qualify type, context
+        rns, rsc = extract_namespace_and_scope(type)
+        res = api_map.qualify(rns, context)
+        return res if rsc == :instance
+        type.sub(/<#{rns}>/, "<#{res}>")
+      end
+
+      # Extract a namespace from a type.
+      #
+      # @example
+      #   extract_namespace('String') => 'String'
+      #   extract_namespace('Class<String>') => 'String'
+      #
+      # @return [String]
+      def extract_namespace type
+        extract_namespace_and_scope(type)[0]
+      end
+
+      # Extract a namespace and a scope (:instance or :class) from a type.
+      #
+      # @example
+      #   extract_namespace('String')            #=> ['String', :instance]
+      #   extract_namespace('Class<String>')     #=> ['String', :class]
+      #   extract_namespace('Module<Enumerable') #=> ['Enumberable', :class]
+      #
+      # @return [Array] The namespace (String) and scope (Symbol).
+      def extract_namespace_and_scope type
+        scope = :instance
+        result = type.to_s.gsub(/<.*$/, '')
+        if (result == 'Class' or result == 'Module') and type.include?('<')
+          result = type.match(/<([a-z0-9:_]*)/i)[1]
+          scope = :class
+        end
+        [result, scope]
+      end
+
+      # Extract a namespace and a scope from a pin. For now, the pin must
+      # be either a method or a namespace. It probably makes sense to support
+      # blocks at some point.
+      #
+      # @return [Array] The namespace (String) and scope (Symbol).
+      def extract_namespace_and_scope_from_pin pin
+        return [pin.namespace, pin.scope] if pin.kind == Pin::METHOD
+        return [pin.namespace, :class] if pin.kind == Pin::NAMESPACE
+        # @todo Is :class appropriate for blocks?
+        return [pin.namespace, :class] if pin.kind == Pin::BLOCK
+        raise "Unable to extract namespace and scope from #{pin.path}"
+      end
+
+      # Determine whether or not the word represents a variable. This method
+      # is used to keep the probe from performing unnecessary constant and
+      # method searches.
+      #
+      # @return [Boolean]
+      def variable_name? word
+        word.start_with?('@') or word.start_with?('$')
+      end
+
+      # Create a `new` pin to facilitate type inference. This is necessary for
+      # classes from YARD and classes in the namespace that do not have an
+      # `initialize` method.
+      #
+      # @return [Pin::Method]
+      def virtual_new_pin new_pin, context_pin
+        pin = Pin::Method.new(new_pin.location, new_pin.namespace, new_pin.name, new_pin.docstring, new_pin.scope, new_pin.visibility, new_pin.parameters)
+        # @todo Smelly instance variable access.
+        pin.instance_variable_set(:@return_type, context_pin.path)
+        pin
+      end
+
+      def resolve_pin_type pin
+        pin.return_type
+        return pin.return_type unless pin.return_type.nil?
+        return resolve_block_parameter(pin) if pin.kind == Pin::BLOCK_PARAMETER
+        return resolve_variable(pin) if pin.variable?
+        nil
+      end
+
+      def resolve_block_parameter pin
+        return pin.return_type unless pin.return_type.nil?
+        signature = pin.block.receiver
+        # @todo Not sure if assuming the first pin is good here
+        meth = @api_map.probe.infer_signature_pins(signature, pin.block, []).first
+        return nil if meth.nil?
+        if (Solargraph::CoreFills::METHODS_WITH_YIELDPARAM_SUBTYPES.include?(meth.path))
+          base = signature.split('.')[0..-2].join('.')
+          return nil if base.nil? or base.empty?
+          # @todo Not sure if assuming the first pin is good here
+          bmeth = @api_map.probe.infer_signature_pins(base, pin.block, []).first
+          return nil if bmeth.nil?
+          subtypes = get_subtypes(bmeth.return_type)
+          return subtypes[0]
+        else
+          unless meth.docstring.nil?
+            yps = meth.docstring.tags(:yieldparam)
+            unless yps[pin.index].nil? or yps[pin.index].types.nil? or yps[pin.index].types.empty?
+              return yps[pin.index].types[0]
+            end
+          end
+        end
+        nil
+      end
+
+      def resolve_variable(pin)
+        return nil if pin.nil_assignment?
+        # @todo Do we need the locals here?
+        return infer_signature_type(pin.signature, pin.context, [])
+      end
+
+      def get_subtypes type
+        return nil if type.nil?
+        match = type.match(/<([a-z0-9_:, ]*)>/i)
+        return [] if match.nil?
+        match[1].split(',').map(&:strip)
+      end
+    end
+  end
+end

data/lib/solargraph/api_map/source_to_yard.rb

@@ -25,7 +25,7 @@ module Solargraph
               code_object_map[pin.path] ||= YARD::CodeObjects::ModuleObject.new(root_code_object, pin.path)
             end
             code_object_map[pin.path].docstring = pin.docstring unless pin.docstring.nil?
-            code_object_map[pin.path].files.push pin.source.filename
+            code_object_map[pin.path].files.push pin.location.filename
           end
           s.namespace_pins.each do |pin|
             pin.include_references.each do |ref|
@@ -35,13 +35,13 @@ module Solargraph
           s.attribute_pins.each do |pin|
             code_object_map[pin.path] ||= YARD::CodeObjects::MethodObject.new(code_object_at(pin.namespace), pin.name, :instance)
             code_object_map[pin.path].docstring = pin.docstring unless pin.docstring.nil?
-            code_object_map[pin.path].files.push pin.source.filename
+            code_object_map[pin.path].files.push pin.location.filename
             #code_object_map[pin.path].parameters = []
           end
           s.method_pins.each do |pin|
             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 unless pin.docstring.nil?
-            code_object_map[pin.path].files.push pin.source.filename
+            code_object_map[pin.path].files.push pin.location.filename
             code_object_map[pin.path].parameters = pin.parameters.map do |p|
               n = p.match(/^[a-z0-9_]*:?/i)[0]
               v = nil

data/lib/solargraph/api_map/store.rb

@@ -0,0 +1,135 @@
+require 'set'
+
+module Solargraph
+  class ApiMap
+    class Store
+      # @param sources [Solargraph::Source]
+      def initialize sources
+        update *sources
+        index
+      end
+
+      def pins
+        @pins ||= []
+      end
+
+      def remove *sources
+        sources.each do |source|
+          pins.delete_if { |pin| pin.filename == source.filename }
+          symbols.delete_if { |pin| pin.filename == source.filename }
+        end
+        index
+      end
+
+      def update *sources
+        sources.each do |source|
+          pins.delete_if { |pin| pin.filename == source.filename }
+          symbols.delete_if { |pin| pin.filename == source.filename }
+          pins.concat source.pins
+          symbols.concat source.symbols
+        end
+        index
+      end
+
+      def get_constants fqns, visibility = [:public]
+        namespace_pins(fqns).select { |pin|
+          !pin.name.empty? and (pin.kind == Pin::NAMESPACE or pin.kind == Pin::CONSTANT) and visibility.include?(pin.visibility)
+        }
+      end
+
+      def get_methods fqns, scope: :instance, visibility: [:public]
+        namespace_pins(fqns).select{ |pin|
+          pin.kind == Pin::METHOD and (pin.scope == scope or fqns == '') and visibility.include?(pin.visibility)
+        }
+      end
+
+      def get_attrs fqns
+        namespace_pins(fqns).select{ |pin| pin.kind == Pin::ATTRIBUTE }
+      end
+
+      def get_superclass fqns
+        fqns_pins(fqns).each do |pin|
+          return pin.superclass_reference.name unless pin.superclass_reference.nil?
+        end
+        nil
+      end
+
+      def get_includes fqns
+        result = []
+        fqns_pins(fqns).each do |pin|
+          result.concat pin.include_references.map(&:name)
+        end
+        result
+      end
+
+      def get_extends fqns
+        result = []
+        fqns_pins(fqns).each do |pin|
+          result.concat pin.extend_references.map(&:name)
+        end
+        result
+      end
+
+      def get_path_pins path
+        base = path.sub(/(#|\.|::)[a-z0-9_]*(\?|\!)?$/i, '')
+        base = '' if base == path
+        namespace_pins(base).select{ |pin| pin.path == path }
+      end
+
+      def get_instance_variables(fqns, scope = :instance)
+        namespace_pins(fqns).select{|pin| pin.kind == Pin::INSTANCE_VARIABLE and pin.scope == scope}
+      end
+
+      def get_symbols
+        symbols.uniq(&:name)
+      end
+
+      def namespace_exists?(fqns)
+        fqns_pins(fqns).any?
+      end
+
+      def namespaces
+        @namespaces ||= Set.new
+      end
+
+      private
+
+      def fqns_pins fqns
+        # @todo We probably want to ignore '' namespace here
+        return [] if fqns.nil? #or fqns.empty?
+        if fqns.include?('::')
+          parts = fqns.split('::')
+          name = parts.pop
+          base = parts.join('::')
+        else
+          base = ''
+          name = fqns
+        end
+        namespace_pins(base).select{|pin| pin.name == name and pin.kind == Pin::NAMESPACE}
+      end
+
+      def symbols
+        @symbols ||= []
+      end
+
+      def namespace_pins name
+        namespace_map[name] || []
+      end
+
+      def namespace_map
+        @namespace_map ||= {}
+      end
+
+      def index
+        namespace_map.clear
+        namespaces.clear
+        namespace_map[''] = []
+        pins.each do |pin|
+          namespace_map[pin.namespace] ||= []
+          namespace_map[pin.namespace].push pin
+          namespaces.add pin.path if pin.kind == Pin::NAMESPACE and !pin.path.empty?
+        end
+      end
+    end
+  end
+end