solargraph 0.39.0 → 0.40.0

data/lib/solargraph/pin/block.rb

@@ -9,22 +9,19 @@ module Solargraph
       attr_reader :receiver
 
       def initialize receiver: nil, args: [], **splat
-        super(splat)
+        super(**splat)
         @receiver = receiver
         @parameters = args
       end
 
-      def rebind context
-        @rebound = true
-        @binder = context unless context.undefined?
-      end
-
-      def rebound?
-        @rebound ||= false
+      # @param api_map [ApiMap]
+      # @return [void]
+      def rebind api_map
+        @binder ||= binder_or_nil(api_map)
       end
 
       def binder
-        @binder || context
+        @binder || closure.binder
       end
 
       # @return [Array<String>]
@@ -37,11 +34,28 @@ module Solargraph
         @parameter_names ||= parameters.map(&:name)
       end
 
-      def nearly? other
-        return false unless super
-        # @todo Trying to not to block merges too much
-        # receiver == other.receiver and parameters == other.parameters
-        true
+      private
+
+      # @param api_map [ApiMap]
+      # @return [ComplexType, nil]
+      def binder_or_nil api_map
+        return nil unless receiver
+        word = receiver.children.find { |c| c.is_a?(::Symbol) }.to_s
+        return nil unless api_map.rebindable_method_names.include?(word)
+        chain = Parser.chain(receiver, location.filename)
+        locals = api_map.source_map(location.filename).locals_at(location)
+        if ['instance_eval', 'instance_exec', 'class_eval', 'class_exec', 'module_eval', 'module_exec'].include?(chain.links.last.word)
+          return chain.base.infer(api_map, self, locals)
+        else
+          receiver_pin = chain.define(api_map, self, locals).first
+          if receiver_pin && receiver_pin.docstring
+            ys = receiver_pin.docstring.tag(:yieldself)
+            if ys && ys.types && !ys.types.empty?
+              return ComplexType.try_parse(*ys.types).qualify(api_map, receiver_pin.context.namespace)
+            end
+          end
+        end
+        nil
       end
     end
   end

data/lib/solargraph/pin/closure.rb

@@ -7,7 +7,7 @@ module Solargraph
       attr_reader :scope
 
       def initialize scope: :class, **splat
-        super(splat)
+        super(**splat)
         @scope = scope
       end
 

data/lib/solargraph/pin/common.rb

@@ -54,7 +54,7 @@ module Solargraph
         until here.nil?
           if here.is_a?(Pin::Namespace)
             return here.return_type
-          elsif here.is_a?(Pin::BaseMethod)
+          elsif here.is_a?(Pin::Method)
             if here.scope == :instance
               return ComplexType.try_parse(here.context.namespace)
             else

data/lib/solargraph/pin/constant.rb

@@ -6,7 +6,7 @@ module Solargraph
       attr_reader :visibility
 
       def initialize visibility: :public, **splat
-        super(splat)
+        super(**splat)
         @visibility = visibility
       end
 

data/lib/solargraph/pin/conversions.rb

@@ -23,16 +23,15 @@ module Solargraph
 
       # @return [Hash]
       def resolve_completion_item
-        if @resolve_completion_item.nil?
+        @resolve_completion_item ||= begin
           extra = {}
           alldoc = ''
           # alldoc += link_documentation unless link_documentation.nil?
           # alldoc += "\n\n" unless alldoc.empty?
           alldoc += documentation unless documentation.nil?
           extra[:documentation] = alldoc unless alldoc.empty?
-          @resolve_completion_item = completion_item.merge(extra)
+          completion_item.merge(extra)
         end
-        @resolve_completion_item
       end
 
       # @return [Hash]
@@ -48,7 +47,7 @@ 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::BaseMethod) || parameters.empty?
+        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/documenting.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require 'maruku'
+require 'kramdown'
+require 'kramdown-parser-gfm'
 require 'yard'
 require 'reverse_markdown'
 require 'solargraph/converters/dl'
@@ -8,9 +9,6 @@ require 'solargraph/converters/dt'
 require 'solargraph/converters/dd'
 require 'solargraph/converters/misc'
 
-# HACK: Setting :html_parser through `Maruku.new` does not work
-MaRuKu::Globals[:html_parser] = 'nokogiri'
-
 module Solargraph
   module Pin
     # A module to add the Pin::Base#documentation method.
@@ -41,11 +39,7 @@ module Solargraph
 
         def to_s
           return "\n```ruby\n#{@plaintext}#{@plaintext.end_with?("\n") ? '' : "\n"}```\n\n" if code?
-          ReverseMarkdown.convert unescape_brackets(Maruku.new(escape_brackets(@plaintext), on_error: :raise).to_html)
-        rescue MaRuKu::Exception
-          # Maruku exceptions usually indicate that the documentation is in
-          # RDoc syntax.
-          ReverseMarkdown.convert YARD::Templates::Helpers::Markup::RDocMarkup.new(@plaintext).to_html
+          ReverseMarkdown.convert unescape_brackets(Kramdown::Document.new(escape_brackets(@plaintext), input: 'GFM').to_html)
         end
 
         private
@@ -53,13 +47,14 @@ module Solargraph
         # @param text [String]
         # @return [String]
         def escape_brackets text
-          text.gsub(/(\[[^\]]*\])([^\(]|\z)/, '!!!`\1`!!!\2')
+          # text.gsub(/(\[[^\]]*\])([^\(]|\z)/, '!!!^\1^!!!\2')
+          text.gsub('[', '!!!!b').gsub(']', 'e!!!!')
         end
 
         # @param text [String]
         # @return [String]
         def unescape_brackets text
-          text.gsub('!!!`[', '[').gsub(']`!!!', ']')
+          text.gsub('!!!!b', '[').gsub('e!!!!', ']')
         end
       end
 

data/lib/solargraph/pin/local_variable.rb

@@ -6,7 +6,7 @@ module Solargraph
       include Localized
 
       def initialize assignment: nil, presence: nil, **splat
-        super(splat)
+        super(**splat)
         @assignment = assignment
         @presence = presence
       end

data/lib/solargraph/pin/method.rb

@@ -2,18 +2,29 @@
 
 module Solargraph
   module Pin
-    class Method < BaseMethod
+    # The base class for method and attribute pins.
+    #
+    class Method < Closure
       include Solargraph::Parser::NodeMethods
 
-      # @return [Array<String>]
+      # @return [Array<Pin::Parameter>]
       attr_reader :parameters
 
-      # @param args [Array<String>]
-      # @param node [Parser::AST::Node, nil]
-      def initialize parameters: [], node: nil, **splat
-        super(splat)
+      # @return [::Symbol] :public, :private, or :protected
+      attr_reader :visibility
+
+      # @return [Parser::AST::Node]
+      attr_reader :node
+
+      # @param visibility [::Symbol] :public, :protected, or :private
+      # @param explicit [Boolean]
+      def initialize visibility: :public, explicit: true, parameters: [], node: nil, attribute: false, **splat
+        super(**splat)
+        @visibility = visibility
+        @explicit = explicit
         @parameters = parameters
         @node = node
+        @attribute = attribute
       end
 
       # @return [Array<String>]
@@ -22,11 +33,70 @@ module Solargraph
       end
 
       def completion_item_kind
-        Solargraph::LanguageServer::CompletionItemKinds::METHOD
+        attribute? ? Solargraph::LanguageServer::CompletionItemKinds::PROPERTY : Solargraph::LanguageServer::CompletionItemKinds::METHOD
       end
 
       def symbol_kind
-        LanguageServer::SymbolKinds::METHOD
+        attribute? ? Solargraph::LanguageServer::SymbolKinds::PROPERTY : LanguageServer::SymbolKinds::METHOD
+      end
+
+      def return_type
+        @return_type ||= generate_complex_type
+      end
+
+      def path
+        @path ||= "#{namespace}#{(scope == :instance ? '#' : '.')}#{name}"
+      end
+
+      def typify api_map
+        decl = super
+        return decl unless decl.undefined?
+        type = see_reference(api_map) || typify_from_super(api_map)
+        return type.qualify(api_map, namespace) unless type.nil?
+        name.end_with?('?') ? ComplexType::BOOLEAN : ComplexType::UNDEFINED
+      end
+
+      def documentation
+        if @documentation.nil?
+          @documentation ||= super || ''
+          param_tags = docstring.tags(:param)
+          unless param_tags.nil? or param_tags.empty?
+            @documentation += "\n\n" unless @documentation.empty?
+            @documentation += "Params:\n"
+            lines = []
+            param_tags.each do |p|
+              l = "* #{p.name}"
+              l += " [#{escape_brackets(p.types.join(', '))}]" unless p.types.nil? or p.types.empty?
+              l += " #{p.text}"
+              lines.push l
+            end
+            @documentation += lines.join("\n")
+          end
+          return_tags = docstring.tags(:return)
+          unless return_tags.empty?
+            @documentation += "\n\n" unless @documentation.empty?
+            @documentation += "Returns:\n"
+            lines = []
+            return_tags.each do |r|
+              l = "*"
+              l += " [#{escape_brackets(r.types.join(', '))}]" unless r.types.nil? or r.types.empty?
+              l += " #{r.text}"
+              lines.push l
+            end
+            @documentation += lines.join("\n")
+          end
+          @documentation += "\n\n" unless @documentation.empty?
+          @documentation += "Visibility: #{visibility}"
+        end
+        @documentation.to_s
+      end
+
+      def explicit?
+        @explicit
+      end
+
+      def attribute?
+        @attribute
       end
 
       def nearly? other
@@ -37,7 +107,7 @@ module Solargraph
       end
 
       def probe api_map
-        infer_from_return_nodes(api_map)
+        attribute? ? infer_from_iv(api_map) : infer_from_return_nodes(api_map)
       end
 
       def try_merge! pin
@@ -70,6 +140,57 @@ module Solargraph
 
       private
 
+      # @return [ComplexType]
+      def generate_complex_type
+        tags = docstring.tags(:return).map(&:types).flatten.reject(&:nil?)
+        return ComplexType::UNDEFINED if tags.empty?
+        ComplexType.try_parse *tags
+      end
+
+      # @param api_map [ApiMap]
+      # @return [ComplexType, nil]
+      def see_reference api_map
+        docstring.ref_tags.each do |ref|
+          next unless ref.tag_name == 'return' && ref.owner
+          result = resolve_reference(ref.owner.to_s, api_map)
+          return result unless result.nil?
+        end
+        match = comments.match(/^[ \t]*\(see (.*)\)/m)
+        return nil if match.nil?
+        resolve_reference match[1], api_map
+      end
+
+      # @param api_map [ApiMap]
+      # @return [ComplexType, nil]
+      def typify_from_super api_map
+        stack = api_map.get_method_stack(namespace, name, scope: scope).reject { |pin| pin.path == path }
+        return nil if stack.empty?
+        stack.each do |pin|
+          return pin.return_type unless pin.return_type.undefined?
+        end
+        nil
+      end
+
+      # @param ref [String]
+      # @param api_map [ApiMap]
+      # @return [ComplexType]
+      def resolve_reference ref, api_map
+        parts = ref.split(/[\.#]/)
+        if parts.first.empty? || parts.one?
+          path = "#{namespace}#{ref}"
+        else
+          fqns = api_map.qualify(parts.first, namespace)
+          return ComplexType::UNDEFINED if fqns.nil?
+          path = fqns + ref[parts.first.length] + parts.last
+        end
+        pins = api_map.get_path_pins(path)
+        pins.each do |pin|
+          type = pin.typify(api_map)
+          return type unless type.undefined?
+        end
+        nil
+      end
+
       # @return [Parser::AST::Node, nil]
       def method_body_node
         return nil if node.nil?
@@ -106,6 +227,19 @@ module Solargraph
         return ComplexType::UNDEFINED if result.empty?
         ComplexType.try_parse(*result.map(&:tag).uniq)
       end
+
+      def infer_from_iv api_map
+        types = []
+        varname = "@#{name.gsub(/=$/, '')}"
+        pins = api_map.get_instance_variable_pins(binder.namespace, binder.scope).select { |iv| iv.name == varname }
+        pins.each do |pin|
+          type = pin.typify(api_map)
+          type = pin.probe(api_map) if type.undefined?
+          types.push type if type.defined?
+        end
+        return ComplexType::UNDEFINED if types.empty?
+        ComplexType.try_parse(*types.map(&:tag).uniq)
+      end
     end
   end
 end

data/lib/solargraph/pin/method_alias.rb

@@ -6,7 +6,7 @@ module Solargraph
     # examples that defer mapping are aliases for superclass methods or
     # methods from included modules.
     #
-    class MethodAlias < BaseMethod
+    class MethodAlias < Method
       # @return [::Symbol]
       attr_reader :scope
 
@@ -14,7 +14,7 @@ module Solargraph
       attr_reader :original
 
       def initialize scope: :instance, original: nil, **splat
-        super(splat)
+        super(**splat)
         @scope = scope
         @original = original
       end

data/lib/solargraph/pin/namespace.rb

@@ -14,7 +14,7 @@ module Solargraph
       # @param gates [Array<String>]
       def initialize type: :class, visibility: :public, gates: [''], **splat
         # super(location, namespace, name, comments)
-        super(splat)
+        super(**splat)
         @type = type
         @visibility = visibility
         if name.start_with?('::')

data/lib/solargraph/pin/parameter.rb

@@ -8,7 +8,7 @@ module Solargraph
       attr_reader :asgn_code
 
       def initialize decl: :arg, asgn_code: nil, **splat
-        super(splat)
+        super(**splat)
         @asgn_code = asgn_code
         @decl = decl
       end
@@ -41,7 +41,7 @@ module Solargraph
           "*#{name}"
         when :kwrestarg
           "**#{name}"
-        when :block
+        when :block, :blockarg
           "&#{name}"
         else
           name

data/lib/solargraph/pin/proxy_type.rb

@@ -5,7 +5,7 @@ module Solargraph
     class ProxyType < Base
       # @param return_type [ComplexType]
       def initialize return_type: ComplexType::UNDEFINED, **splat
-        super(splat)
+        super(**splat)
         @return_type = return_type
       end
 

data/lib/solargraph/pin.rb

@@ -9,10 +9,8 @@ module Solargraph
     autoload :Common,           'solargraph/pin/common'
     autoload :Conversions,      'solargraph/pin/conversions'
     autoload :Base,             'solargraph/pin/base'
-    autoload :BaseMethod,       'solargraph/pin/base_method'
     autoload :Method,           'solargraph/pin/method'
     autoload :MethodAlias,      'solargraph/pin/method_alias'
-    autoload :Attribute,        'solargraph/pin/attribute'
     autoload :BaseVariable,     'solargraph/pin/base_variable'
     autoload :InstanceVariable, 'solargraph/pin/instance_variable'
     autoload :ClassVariable,    'solargraph/pin/class_variable'
@@ -30,7 +28,6 @@ module Solargraph
     autoload :Localized,        'solargraph/pin/localized'
     autoload :ProxyType,        'solargraph/pin/proxy_type'
     autoload :DuckMethod,       'solargraph/pin/duck_method'
-    autoload :YardPin,          'solargraph/pin/yard_pin'
     autoload :Singleton,        'solargraph/pin/singleton'
     autoload :KeywordParam,     'solargraph/pin/keyword_param'
 

data/lib/solargraph/position.rb

@@ -40,20 +40,8 @@ module Solargraph
     # @param position [Position]
     # @return [Integer]
     def self.to_offset text, position
-      result = 0
-      feed = 0
-      line = position.line
-      column = position.character
-      text.lines.each do |l|
-        line_length = l.length
-        if feed == line
-          result += column
-          break
-        end
-        result += line_length
-        feed += 1
-      end
-      result
+      return 0 if text.empty?
+      text.lines[0...position.line].sum(&:length) + position.character
     end
 
     # Get a numeric offset for the specified text and a position identified

data/lib/solargraph/shell.rb

@@ -153,6 +153,7 @@ module Solargraph
         probcount += problems.length
       end
       puts "#{probcount} problem#{probcount != 1 ? 's' : ''} found#{files.length != 1 ? " in #{filecount} of #{files.length} files" : ''}."
+      exit 1 if probcount > 0
     end
 
     desc 'scan', 'Test the workspace for problems'
@@ -175,7 +176,7 @@ module Solargraph
             puts pin_description(pin) if options[:verbose]
             pin.typify api_map
             pin.probe api_map
-          rescue Exception => e
+          rescue StandardError => e
             STDERR.puts "Error testing #{pin_description(pin)} #{pin.location ? "at #{pin.location.filename}:#{pin.location.range.start.line + 1}" : ''}"
             STDERR.puts "[#{e.class}]: #{e.message}"
             STDERR.puts e.backtrace.join("\n")

data/lib/solargraph/source/chain/call.rb

@@ -28,6 +28,7 @@ module Solargraph
         # @param name_pin [Pin::Base]
         # @param locals [Array<Pin::Base>]
         def resolve api_map, name_pin, locals
+          return super_pins(api_map, name_pin) if word == 'super'
           found = if head?
             locals.select { |p| p.name == word }
           else
@@ -188,6 +189,14 @@ module Solargraph
           return false if argcount < parcount && !(argcount == parcount - 1 && parameters.last.first.start_with?('*'))
           true
         end
+
+        # @param api_map [ApiMap]
+        # @param name_pin [Pin::Base]
+        # @return [Array<Pin::Base>]
+        def super_pins api_map, name_pin
+          pins = api_map.get_method_stack(name_pin.namespace, name_pin.name, scope: name_pin.scope)
+          pins.reject{|p| p.path == name_pin.path}
+        end
       end
     end
   end

data/lib/solargraph/source/chain/head.rb

@@ -10,19 +10,25 @@ module Solargraph
       class Head < Link
         def resolve api_map, name_pin, locals
           return [Pin::ProxyType.anonymous(name_pin.binder)] if word == 'self'
-          return super_pins(api_map, name_pin) if word == 'super'
+          # return super_pins(api_map, name_pin) if word == 'super'
           []
         end
 
+        # @todo This is temporary. Chain heads need to handle arguments to
+        #   `super`.
+        # def arguments
+        #   []
+        # end
+
         private
 
-        # @param api_map [ApiMap]
-        # @param name_pin [Pin::Base]
-        # @return [Array<Pin::Base>]
-        def super_pins api_map, name_pin
-          pins = api_map.get_method_stack(name_pin.namespace, name_pin.name, scope: name_pin.scope)
-          pins.reject{|p| p.path == name_pin.path}
-        end
+        # # @param api_map [ApiMap]
+        # # @param name_pin [Pin::Base]
+        # # @return [Array<Pin::Base>]
+        # def super_pins api_map, name_pin
+        #   pins = api_map.get_method_stack(name_pin.namespace, name_pin.name, scope: name_pin.scope)
+        #   pins.reject{|p| p.path == name_pin.path}
+        # end
       end
     end
   end

data/lib/solargraph/source/chain/z_super.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class ZSuper < Call
+        # @return [String]
+        attr_reader :word
+
+        # @return [Array<Chain>]
+        attr_reader :arguments
+
+        # @param word [String]
+        # @param arguments [Array<Chain>]
+        # @param with_block [Boolean] True if the chain is inside a block
+        # @param head [Boolean] True if the call is the start of its chain
+        def initialize word, with_block = false
+          super(word, [], with_block)
+        end
+
+        # @param api_map [ApiMap]
+        # @param name_pin [Pin::Base]
+        # @param locals [Array<Pin::Base>]
+        def resolve api_map, name_pin, locals
+          return super_pins(api_map, name_pin)
+        end
+      end
+    end
+  end
+end