solargraph 0.45.0 → 0.49.0

data/lib/solargraph/pin/block.rb

@@ -8,6 +8,7 @@ module Solargraph
       # @return [Parser::AST::Node]
       attr_reader :receiver
 
+      # @param args [Array<Parameter>]
       def initialize receiver: nil, args: [], context: nil, **splat
         super(**splat)
         @receiver = receiver
@@ -25,7 +26,7 @@ module Solargraph
         @binder || closure.binder
       end
 
-      # @return [Array<String>]
+      # @return [Array<Parameter>]
       def parameters
         @parameters ||= []
       end

data/lib/solargraph/pin/conversions.rb

@@ -34,12 +34,9 @@ module Solargraph
         end
       end
 
-      # @return [Hash]
+      # @return [Array<Hash>]
       def signature_help
-        @signature_help ||= {
-          label: name + '(' + parameters.map(&:full).join(', ') + ')',
-          documentation: documentation
-        }
+        []
       end
 
       # @return [String]
@@ -47,7 +44,6 @@ module Solargraph
         # This property is not cached in an instance variable because it can
         # change when pins get proxied.
         detail = String.new
-        detail += "(#{parameters.map(&:full).join(', ')}) " unless !is_a?(Pin::Method) || parameters.empty?
         detail += "=#{probed? ? '~' : (proxied? ? '^' : '>')} #{return_type.to_s}" unless return_type.undefined?
         detail.strip!
         return nil if detail.empty?

data/lib/solargraph/pin/method.rb

@@ -18,13 +18,18 @@ module Solargraph
 
       # @param visibility [::Symbol] :public, :protected, or :private
       # @param explicit [Boolean]
-      def initialize visibility: :public, explicit: true, parameters: [], node: nil, attribute: false, **splat
+      # @param parameters [Array<Pin::Parameter>]
+      # @param node [Parser::AST::Node, RubyVM::AbstractSyntaxTree::Node]
+      # @param attribute [Boolean]
+      def initialize visibility: :public, explicit: true, parameters: [], node: nil, attribute: false, signatures: nil, anon_splat: false, **splat
         super(**splat)
         @visibility = visibility
         @explicit = explicit
         @parameters = parameters
         @node = node
         @attribute = attribute
+        @signatures = signatures
+        @anon_splat = anon_splat
       end
 
       # @return [Array<String>]
@@ -41,7 +46,45 @@ module Solargraph
       end
 
       def return_type
-        @return_type ||= generate_complex_type
+        @return_type ||= ComplexType.try_parse(*signatures.map(&:return_type).map(&:to_s))
+      end
+
+      # @return [Array<Signature>]
+      def signatures
+        @signatures ||= begin
+          top_type = generate_complex_type
+          result = []
+          result.push Signature.new(parameters, top_type) if top_type.defined?
+          result.concat(overloads.map { |meth| Signature.new(meth.parameters, meth.return_type) })
+          result.push Signature.new(parameters, top_type) if result.empty?
+          result
+        end
+      end
+
+      # @return [String]
+      def detail
+        # This property is not cached in an instance variable because it can
+        # change when pins get proxied.
+        detail = String.new
+        detail += if signatures.length > 1
+          "(*) "
+        else
+          "(#{signatures.first.parameters.map(&:full).join(', ')}) " unless signatures.first.parameters.empty?
+        end.to_s
+        detail += "=#{probed? ? '~' : (proxied? ? '^' : '>')} #{return_type.to_s}" unless return_type.undefined?
+        detail.strip!
+        return nil if detail.empty?
+        detail
+      end
+
+      # @return [Array<Hash>]
+      def signature_help
+        @signature_help ||= signatures.map do |sig|
+          {
+            label: name + '(' + sig.parameters.map(&:full).join(', ') + ')',
+            documentation: documentation
+          }
+        end
       end
 
       def path
@@ -119,27 +162,60 @@ module Solargraph
       # @return [Array<Pin::Method>]
       def overloads
         @overloads ||= docstring.tags(:overload).map do |tag|
-          Solargraph::Pin::Method.new(
-            name: name,
-            closure: self,
-            # args: tag.parameters.map(&:first),
-            parameters: tag.parameters.map do |src|
+          Pin::Signature.new(
+            tag.parameters.map do |src|
+              name, decl = parse_overload_param(src.first)
               Pin::Parameter.new(
                 location: location,
                 closure: self,
                 comments: tag.docstring.all.to_s,
-                name: src.first,
+                name: name,
+                decl: decl,
                 presence: location ? location.range : nil,
-                decl: :arg
+                return_type: param_type_from_name(tag, src.first)
               )
             end,
-            comments: tag.docstring.all.to_s
+            ComplexType.try_parse(*tag.docstring.tags(:return).flat_map(&:types))
           )
         end
+        @overloads
+      end
+
+      def anon_splat?
+        @anon_splat
       end
 
       private
 
+      def select_decl name, asgn
+        if name.start_with?('**')
+          :kwrestarg
+        elsif name.start_with?('*')
+          :restarg
+        elsif name.start_with?('&')
+          :blockarg
+        elsif name.end_with?(':') && asgn
+          :kwoptarg
+        elsif name.end_with?(':')
+          :kwarg
+        elsif asgn
+          :optarg
+        else
+          :arg
+        end
+      end
+
+      def clean_param name
+        name.gsub(/[*&:]/, '')
+      end
+
+      # @param tag [YARD::Tags::OverloadTag]
+      def param_type_from_name(tag, name)
+        param = tag.tags(:param).select { |t| t.name == name }.first
+        return ComplexType::UNDEFINED unless param
+        ComplexType.try_parse(*param.types)
+      end
+
       # @return [ComplexType]
       def generate_complex_type
         tags = docstring.tags(:return).map(&:types).flatten.reject(&:nil?)
@@ -240,6 +316,20 @@ module Solargraph
         return ComplexType::UNDEFINED if types.empty?
         ComplexType.try_parse(*types.map(&:tag).uniq)
       end
+
+      # When YARD parses an overload tag, it includes rest modifiers in the parameters names.
+      #
+      # @param arg [String]
+      # @return [Array(String, Symbol)]
+      def parse_overload_param(name)
+        if name.start_with?('**')
+          [name[2..-1], :kwrestarg]
+        elsif name.start_with?('*')
+          [name[1..-1], :restarg]
+        else
+          [name, :arg]
+        end
+      end
     end
   end
 end

data/lib/solargraph/pin/namespace.rb

@@ -9,10 +9,12 @@ module Solargraph
       # @return [::Symbol] :class or :module
       attr_reader :type
 
+      attr_reader :parameters
+
       # @param type [::Symbol] :class or :module
       # @param visibility [::Symbol] :public or :private
       # @param gates [Array<String>]
-      def initialize type: :class, visibility: :public, gates: [''], **splat
+      def initialize type: :class, visibility: :public, gates: [''], parameters: [], **splat
         # super(location, namespace, name, comments)
         super(**splat)
         @type = type
@@ -36,6 +38,7 @@ module Solargraph
           @closure = Pin::Namespace.new(name: closure_name, gates: [parts.join('::')])
           @context = nil
         end
+        @parameters = parameters
       end
 
       def namespace

data/lib/solargraph/pin/parameter.rb

@@ -3,14 +3,17 @@
 module Solargraph
   module Pin
     class Parameter < LocalVariable
+      # @return [Symbol]
       attr_reader :decl
 
+      # @return [String]
       attr_reader :asgn_code
 
-      def initialize decl: :arg, asgn_code: nil, **splat
+      def initialize decl: :arg, asgn_code: nil, return_type: nil, **splat
         super(**splat)
         @asgn_code = asgn_code
         @decl = decl
+        @return_type = return_type
       end
 
       def keyword?
@@ -29,14 +32,18 @@ module Solargraph
         decl == :restarg || decl == :kwrestarg
       end
 
+      def block?
+        [:block, :blockarg].include?(decl)
+      end
+
       def full
         case decl
         when :optarg
-          "#{name} = #{asgn_code}"
+          "#{name} = #{asgn_code || '?'}"
         when :kwarg
           "#{name}:"
         when :kwoptarg
-          "#{name}: #{asgn_code}"
+          "#{name}: #{asgn_code || '?'}"
         when :restarg
           "*#{name}"
         when :kwrestarg
@@ -91,10 +98,6 @@ module Solargraph
         true
       end
 
-      def probe api_map
-        typify api_map
-      end
-
       private
 
       # @return [YARD::Tags::Tag]

data/lib/solargraph/pin/search.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'jaro_winkler'
+
+module Solargraph
+  module Pin
+    class Search
+      class Result
+        # @return [Float]
+        attr_reader :match
+
+        # @return [Pin::Base]
+        attr_reader :pin
+
+        def initialize match, pin
+          @match = match
+          @pin = pin
+        end
+      end
+
+      # @param pins [Array<Pin::Base>]
+      # @param query [String]
+      def initialize pins, query
+        @pins = pins
+        @query = query
+      end
+
+      # @return [Array<Pin::Base>]
+      def results
+        @results ||= do_query
+      end
+
+      private
+
+      # @return [Array<Pin::Base>]
+      def do_query
+        return @pins if @query.nil? || @query.empty?
+        @pins.map do |pin|
+          match = [fuzzy_string_match(pin.path, @query), fuzzy_string_match(pin.name, @query)].max
+          Result.new(match, pin) if match > 0.7
+        end
+          .compact
+          .sort { |a, b| b.match <=> a.match }
+          .map(&:pin)
+      end
+
+      # @param str1 [String]
+      # @param str2 [String]
+      # @return [Float]
+      def fuzzy_string_match str1, str2
+        return (1.0 + (str2.length.to_f / str1.length.to_f)) if str1.downcase.include?(str2.downcase)
+        JaroWinkler.distance(str1, str2, ignore_case: true)
+      end
+    end
+  end
+end

data/lib/solargraph/pin/signature.rb

@@ -0,0 +1,23 @@
+module Solargraph
+  module Pin
+    class Signature
+      # @return [Array<Parameter>]
+      attr_reader :parameters
+
+      # @return [ComplexType]
+      attr_reader :return_type
+
+      attr_reader :block
+
+      def initialize parameters, return_type, block = nil
+        @parameters = parameters
+        @return_type = return_type
+        @block = block
+      end
+
+      def block?
+        !!@block
+      end
+    end
+  end
+end

data/lib/solargraph/pin.rb

@@ -10,6 +10,7 @@ module Solargraph
     autoload :Conversions,      'solargraph/pin/conversions'
     autoload :Base,             'solargraph/pin/base'
     autoload :Method,           'solargraph/pin/method'
+    autoload :Signature,        'solargraph/pin/signature'
     autoload :MethodAlias,      'solargraph/pin/method_alias'
     autoload :BaseVariable,     'solargraph/pin/base_variable'
     autoload :InstanceVariable, 'solargraph/pin/instance_variable'
@@ -30,6 +31,7 @@ module Solargraph
     autoload :DuckMethod,       'solargraph/pin/duck_method'
     autoload :Singleton,        'solargraph/pin/singleton'
     autoload :KeywordParam,     'solargraph/pin/keyword_param'
+    autoload :Search,           'solargraph/pin/search'
 
     ROOT_PIN = Pin::Namespace.new(type: :class, name: '', closure: nil)
   end