solargraph 0.54.1 → 0.55.0

data/lib/solargraph/convention/struct_definition/struct_definition_node.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    module StructDefinition
+      # A node wrapper for a Struct definition via inheritance.
+      # @example
+      #   class MyStruct < Struct.new(:bar, :baz)
+      #     def foo
+      #     end
+      #   end
+      class StructDefintionNode
+        class << self
+          # @example
+          #   s(:class,
+          #     s(:const, nil, :Foo),
+          #     s(:send,
+          #       s(:const, nil, :Struct), :new,
+          #       s(:sym, :bar),
+          #       s(:sym, :baz)),
+          #       s(:hash,
+          #         s(:pair,
+          #           s(:sym, :keyword_init),
+          #           s(:true)))),
+          #     s(:def, :foo,
+          #       s(:args),
+          #       s(:send, nil, :bar)))
+          def valid?(node)
+            return false unless node&.type == :class
+
+            struct_definition_node?(node.children[1])
+          end
+
+          private
+
+          # @param struct_node [Parser::AST::Node]
+          # @return [Boolean]
+          def struct_definition_node?(struct_node)
+            return false unless struct_node.is_a?(::Parser::AST::Node)
+            return false unless struct_node&.type == :send
+            return false unless struct_node.children[0]&.type == :const
+            return false unless struct_node.children[0].children[1] == :Struct
+            return false unless struct_node.children[1] == :new
+
+            true
+          end
+        end
+
+        # @return [Parser::AST::Node]
+        def initialize(node)
+          @node = node
+        end
+
+        # @return [String]
+        def class_name
+          Parser::NodeMethods.unpack_name(node)
+        end
+
+        # @return [Array<Array(Parser::AST::Node, String)>]
+        def attributes
+          struct_attribute_nodes.map do |struct_def_param|
+            next unless struct_def_param.type == :sym
+            [struct_def_param, struct_def_param.children[0].to_s]
+          end.compact
+        end
+
+        def keyword_init?
+          keyword_init_param = struct_attribute_nodes.find do |struct_def_param|
+            struct_def_param.type == :hash && struct_def_param.children[0].type == :pair &&
+              struct_def_param.children[0].children[0].children[0] == :keyword_init
+          end
+
+          return false if keyword_init_param.nil?
+
+          keyword_init_param.children[0].children[1].type == :true
+        end
+
+        # @return [Parser::AST::Node]
+        def body_node
+          node.children[2]
+        end
+
+        private
+
+        # @return [Parser::AST::Node]
+        attr_reader :node
+
+        # @return [Parser::AST::Node]
+        def struct_node
+          node.children[1]
+        end
+
+        # @return [Array<Parser::AST::Node>]
+        def struct_attribute_nodes
+          struct_node.children[2..-1]
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/convention/struct_definition.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    module StructDefinition
+      autoload :StructDefintionNode, 'solargraph/convention/struct_definition/struct_definition_node'
+      autoload :StructAssignmentNode, 'solargraph/convention/struct_definition/struct_assignment_node'
+
+      module NodeProcessors
+        class StructNode < Parser::NodeProcessor::Base
+          def process
+            return if struct_definition_node.nil?
+
+            loc = get_node_location(node)
+            nspin = Solargraph::Pin::Namespace.new(
+              type: :class,
+              location: loc,
+              closure: region.closure,
+              name: struct_definition_node.class_name,
+              comments: comments_for(node),
+              visibility: :public,
+              gates: region.closure.gates.freeze
+            )
+            pins.push nspin
+
+            # define initialize method
+            initialize_method_pin = Pin::Method.new(
+              name: 'initialize',
+              parameters: [],
+              scope: :instance,
+              location: get_node_location(node),
+              closure: nspin,
+              visibility: :private,
+              comments: comments_for(node)
+            )
+
+            pins.push initialize_method_pin
+
+            struct_definition_node.attributes.map do |attribute_node, attribute_name|
+              initialize_method_pin.parameters.push(
+                Pin::Parameter.new(
+                  name: attribute_name,
+                  decl: struct_definition_node.keyword_init? ? :kwarg : :arg,
+                  location: get_node_location(attribute_node),
+                  closure: initialize_method_pin
+                )
+              )
+            end
+
+            # define attribute accessors and instance variables
+            struct_definition_node.attributes.each do |attribute_node, attribute_name|
+              [attribute_name, "#{attribute_name}="].each do |name|
+                method_pin = Pin::Method.new(
+                  name: name,
+                  parameters: [],
+                  scope: :instance,
+                  location: get_node_location(attribute_node),
+                  closure: nspin,
+                  comments: attribute_comments(attribute_node, attribute_name),
+                  visibility: :public
+                )
+
+                pins.push method_pin
+
+                next unless name.include?('=') # setter
+                pins.push Pin::InstanceVariable.new(name: "@#{attribute_name}",
+                                                    closure: method_pin,
+                                                    location: get_node_location(attribute_node),
+                                                    comments: attribute_comments(attribute_node, attribute_name))
+              end
+            end
+
+            process_children region.update(closure: nspin, visibility: :public)
+          end
+
+          private
+
+          # @return [StructDefintionNode, nil]
+          def struct_definition_node
+            @struct_definition_node ||= if StructDefintionNode.valid?(node)
+                                          StructDefintionNode.new(node)
+                                        elsif StructAssignmentNode.valid?(node)
+                                          StructAssignmentNode.new(node)
+                                        end
+          end
+
+          # @param attribute_node [Parser::AST::Node]
+          # @return [String, nil]
+          def attribute_comments(attribute_node, attribute_name)
+            struct_comments = comments_for(attribute_node)
+            return if struct_comments.nil? || struct_comments.empty?
+
+            struct_comments.split("\n").find do |row|
+              row.include?(attribute_name)
+            end&.gsub('@param', '@return')&.gsub(attribute_name, '')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/convention.rb

@@ -10,7 +10,9 @@ module Solargraph
     autoload :Gemfile, 'solargraph/convention/gemfile'
     autoload :Gemspec, 'solargraph/convention/gemspec'
     autoload :Rakefile, 'solargraph/convention/rakefile'
+    autoload :StructDefinition, 'solargraph/convention/struct_definition'
 
+    # @type [Set<Convention::Base>]
     @@conventions = Set.new
 
     # @param convention [Class<Convention::Base>]

data/lib/solargraph/doc_map.rb

@@ -4,6 +4,8 @@ module Solargraph
   # A collection of pins generated from required gems.
   #
   class DocMap
+    include Logging
+
     # @return [Array<String>]
     attr_reader :requires
 
@@ -28,12 +30,12 @@ module Solargraph
 
     # @return [Array<Gem::Specification>]
     def gemspecs
-      @gemspecs ||= required_gem_map.values.compact
+      @gemspecs ||= required_gems_map.values.compact.flatten
     end
 
     # @return [Array<String>]
     def unresolved_requires
-      @unresolved_requires ||= required_gem_map.select { |_, gemspec| gemspec.nil? }.keys
+      @unresolved_requires ||= required_gems_map.select { |_, gemspecs| gemspecs.nil? }.keys
     end
 
     # @return [Hash{Gem::Specification => Array[Pin::Base]}]
@@ -52,20 +54,22 @@ module Solargraph
     def generate
       @pins = []
       @uncached_gemspecs = []
-      required_gem_map.each do |path, gemspec|
-        if gemspec
-          try_cache gemspec
-        else
+      required_gems_map.each do |path, gemspecs|
+        if gemspecs.nil?
           try_stdlib_map path
+        else
+          gemspecs.each do |gemspec|
+            try_cache gemspec
+          end
         end
       end
       dependencies.each { |dep| try_cache dep }
       @uncached_gemspecs.uniq!
     end
 
-    # @return [Hash{String => Gem::Specification, nil}]
-    def required_gem_map
-      @required_gem_map ||= requires.to_h { |path| [path, resolve_path_to_gemspec(path)] }
+    # @return [Hash{String => Array<Gem::Specification>}]
+    def required_gems_map
+      @required_gems_map ||= requires.to_h { |path| [path, resolve_path_to_gemspecs(path)] }
     end
 
     # @return [Hash{String => Gem::Specification}]
@@ -112,6 +116,7 @@ module Solargraph
       true
     end
 
+    # @param gemspec [Gem::Specification]
     def update_from_collection gemspec, gempins
       return gempins unless @rbs_path && File.directory?(@rbs_path)
       return gempins if RbsMap.new(gemspec.name, gemspec.version).resolved?
@@ -124,10 +129,26 @@ module Solargraph
     end
 
     # @param path [String]
-    # @return [Gem::Specification, nil]
-    def resolve_path_to_gemspec path
+    # @return [::Array<Gem::Specification>, nil]
+    def resolve_path_to_gemspecs path
       return nil if path.empty?
 
+      if path == 'bundler/require'
+        # find only the gems bundler is now using
+        gemspecs = Bundler.definition.locked_gems.specs.flat_map do |lazy_spec|
+          logger.info "Handling #{lazy_spec.name}:#{lazy_spec.version} from #{path}"
+          [Gem::Specification.find_by_name(lazy_spec.name, lazy_spec.version)]
+        rescue Gem::MissingSpecError => e
+          logger.info("Could not find #{lazy_spec.name}:#{lazy_spec.version} with find_by_name, falling back to guess")
+          # can happen in local filesystem references
+          specs = resolve_path_to_gemspecs lazy_spec.name
+          logger.info "Gem #{lazy_spec.name} #{lazy_spec.version} from bundle not found: #{e}" if specs.nil?
+          next specs
+        end.compact
+
+        return gemspecs
+      end
+
       gemspec = Gem::Specification.find_by_path(path)
       if gemspec.nil?
         gem_name_guess = path.split('/').first
@@ -141,16 +162,17 @@ module Solargraph
           gemspec = potential_gemspec if potential_gemspec.files.any? { |gemspec_file| file == gemspec_file }
         rescue Gem::MissingSpecError
           Solargraph.logger.debug "Require path #{path} could not be resolved to a gem via find_by_path or guess of #{gem_name_guess}"
-          nil
+          []
         end
       end
-      gemspec_or_preference gemspec
+      return nil if gemspec.nil?
+      [gemspec_or_preference(gemspec)]
     end
 
-    # @param gemspec [Gem::Specification, nil]
-    # @return [Gem::Specification, nil]
+    # @param gemspec [Gem::Specification]
+    # @return [Gem::Specification]
     def gemspec_or_preference gemspec
-      return gemspec unless gemspec && preference_map.key?(gemspec.name)
+      return gemspec unless preference_map.key?(gemspec.name)
       return gemspec if gemspec.version == preference_map[gemspec.name].version
 
       change_gemspec_version gemspec, preference_map[by_path.name].version
@@ -169,12 +191,15 @@ module Solargraph
     # @param gemspec [Gem::Specification]
     # @return [Array<Gem::Specification>]
     def fetch_dependencies gemspec
+      # @param spec [Gem::Dependency]
       only_runtime_dependencies(gemspec).each_with_object(Set.new) do |spec, deps|
         Solargraph.logger.info "Adding #{spec.name} dependency for #{gemspec.name}"
-        dep = Gem::Specification.find_by_name(spec.name, spec.requirement)
+        dep = Gem.loaded_specs[spec.name]
+        # @todo is next line necessary?
+        dep ||= Gem::Specification.find_by_name(spec.name, spec.requirement)
         deps.merge fetch_dependencies(dep) if deps.add?(dep)
       rescue Gem::MissingSpecError
-        Solargraph.logger.warn "Gem dependency #{spec.name} #{spec.requirements} for #{gemspec.name} not found."
+        Solargraph.logger.warn "Gem dependency #{spec.name} #{spec.requirement} for #{gemspec.name} not found."
       end.to_a
     end
 

data/lib/solargraph/equality.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Solargraph
+  # @abstract This mixin relies on these -
+  #   methods:
+  #     equality_fields()
+  module Equality
+    # @!method equality_fields
+    #   @return [Array]
+
+    # @param other [Object]
+    # @return [Boolean]
+    def eql?(other)
+      self.class.eql?(other.class) &&
+        equality_fields.eql?(other.equality_fields)
+    end
+
+    # @param other [Object]
+    # @return [Boolean]
+    def ==(other)
+      self.eql?(other)
+    end
+
+    def hash
+      equality_fields.hash
+    end
+
+    def freeze
+      equality_fields.each(&:freeze)
+      super
+    end
+  end
+end

data/lib/solargraph/language_server/host/message_worker.rb

@@ -3,12 +3,21 @@
 module Solargraph
   module LanguageServer
     class Host
-      # A serial worker Thread to handle message.
-      #
-      # this make check pending message possible, and maybe cancelled to speedup process
+      # A serial worker Thread to handle incoming messages.
       #
       class MessageWorker
-        UPDATE_METHODS = ['textDocument/didOpen', 'textDocument/didChange', 'workspace/didChangeWatchedFiles'].freeze
+        UPDATE_METHODS = [
+          'textDocument/didChange',
+          'textDocument/didClose',
+          'textDocument/didOpen',
+          'textDocument/didSave',
+          'workspace/didChangeConfiguration',
+          'workspace/didChangeWatchedFiles',
+          'workspace/didCreateFiles',
+          'workspace/didChangeWorkspaceFolders',
+          'workspace/didDeleteFiles',
+          'workspace/didRenameFiles'
+        ].freeze
 
         # @param host [Host]
         def initialize(host)
@@ -64,22 +73,33 @@ module Solargraph
         private
 
         def next_message
-          # Prioritize updates and version-dependent messages for performance
-          idx = messages.find_index do |msg|
-            UPDATE_METHODS.include?(msg['method']) || version_dependent?(msg)
-          end
-          # @todo We might want to clear duplicate instances of this message
-          #   that occur before the next update
-          return messages.shift unless idx
+          cancel_message || next_priority
+        end
+
+        def cancel_message
+          # Handle cancellations first
+          idx = messages.find_index { |msg| msg['method'] == '$/cancelRequest' }
+          return unless idx
 
           msg = messages[idx]
           messages.delete_at idx
           msg
         end
 
+        def next_priority
+          # Prioritize updates and version-dependent messages for performance
+          idx = messages.find_index do |msg|
+            UPDATE_METHODS.include?(msg['method']) || version_dependent?(msg)
+          end
+          idx ? messages.delete_at(idx) : messages.shift
+        end
+
         # True if the message requires a previous update to have executed in
         # order to work correctly.
         #
+        # @param msg [Hash{String => Object}]
+        # @todo need boolish type from RBS
+        # @return [Object]
         def version_dependent? msg
           msg['textDocument'] && msg['position']
         end

data/lib/solargraph/language_server/host.rb

@@ -24,10 +24,8 @@ module Solargraph
       attr_writer :client_capabilities
 
       def initialize
-        @cancel_semaphore = Mutex.new
         @buffer_semaphore = Mutex.new
         @request_mutex = Mutex.new
-        @cancel = []
         @buffer = String.new
         @stopped = true
         @next_request_id = 1
@@ -65,7 +63,7 @@ module Solargraph
       # @param id [Integer]
       # @return [void]
       def cancel id
-        @cancel_semaphore.synchronize { @cancel.push id }
+        cancelled.push id
       end
 
       # True if the host received a request to cancel the method with the
@@ -74,9 +72,7 @@ module Solargraph
       # @param id [Integer]
       # @return [Boolean]
       def cancel? id
-        result = false
-        @cancel_semaphore.synchronize { result = @cancel.include? id }
-        result
+        cancelled.include? id
       end
 
       # Delete the specified ID from the list of cancelled IDs if it exists.
@@ -84,7 +80,7 @@ module Solargraph
       # @param id [Integer]
       # @return [void]
       def clear id
-        @cancel_semaphore.synchronize { @cancel.delete id }
+        cancelled.delete id
       end
 
       # Called by adapter, to handle the request
@@ -101,11 +97,11 @@ module Solargraph
       # @return [Solargraph::LanguageServer::Message::Base, nil] The message handler.
       def receive request
         if request['method']
-          logger.info "Server received #{request['method']}"
+          logger.info "Host received ##{request['id']} #{request['method']}"
           logger.debug request
           message = Message.select(request['method']).new(self, request)
           begin
-            message.process
+            message.process unless cancel?(request['id'])
           rescue StandardError => e
             logger.warn "Error processing request: [#{e.class}] #{e.message}"
             logger.warn e.backtrace.join("\n")
@@ -381,7 +377,6 @@ module Solargraph
           envelope = "Content-Length: #{json.bytesize}\r\n\r\n#{json}"
           queue envelope
           @next_request_id += 1
-          logger.info "Server sent #{method}"
           logger.debug params
         end
       end
@@ -476,6 +471,7 @@ module Solargraph
       def locate_pins params
         return [] unless params['data'] && params['data']['uri']
         library = library_for(params['data']['uri'])
+        # @type [Array<Pin::Base>]
         result = []
         if params['data']['location']
           location = Location.new(
@@ -575,7 +571,7 @@ module Solargraph
       # @param column [Integer]
       # @param strip [Boolean] Strip special characters from variable names
       # @param only [Boolean] If true, search current file only
-      # @return [Array<Solargraph::Range>]
+      # @return [Array<Solargraph::Location>]
       def references_from uri, line, column, strip: true, only: false
         library = library_for(uri)
         library.references_from(uri_to_file(uri), line, column, strip: strip, only: only)
@@ -693,6 +689,11 @@ module Solargraph
 
       private
 
+      # @return [Array<Integer>]
+      def cancelled
+        @cancelled ||= []
+      end
+
       # @return [MessageWorker]
       def message_worker
         @message_worker ||= MessageWorker.new(self)
@@ -748,6 +749,7 @@ module Solargraph
         return change if source.code.length + 1 != change['text'].length
         diffs = Diff::LCS.diff(source.code, change['text'])
         return change if diffs.length.zero? || diffs.length > 1 || diffs.first.length > 1
+        # @sg-ignore push this upstream
         # @type [Diff::LCS::Change]
         diff = diffs.first.first
         return change unless diff.adding? && ['.', ':', '(', ',', ' '].include?(diff.element)

data/lib/solargraph/language_server/message/base.rb

@@ -16,7 +16,7 @@ module Solargraph
         # @return [String]
         attr_reader :method
 
-        # @return [Hash{String => Array, Hash, String, Integer}]
+        # @return [Hash{String => Array<undefined>, Hash{String => undefined}, String, Integer}]
         attr_reader :params
 
         # @return [Hash, Array, nil]
@@ -61,18 +61,11 @@ module Solargraph
         # @return [void]
         def send_response
           return if id.nil?
-          if host.cancel?(id)
-            # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#cancelRequest
-            # cancel should send response RequestCancelled
-            Solargraph::Logging.logger.info "Cancelled response to #{method}"
-            set_result nil
-            set_error ErrorCodes::REQUEST_CANCELLED, "cancelled by client"
-          else
-            Solargraph::Logging.logger.info "Sending response to #{method}"
-          end
+
+          accept_or_cancel
           response = {
-            jsonrpc: "2.0",
-            id: id,
+            jsonrpc: '2.0',
+            id: id
           }
           response[:result] = result unless result.nil?
           response[:error] = error unless error.nil?
@@ -83,6 +76,20 @@ module Solargraph
           host.queue envelope
           host.clear id
         end
+
+        private
+
+        def accept_or_cancel
+          if host.cancel?(id)
+            # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#cancelRequest
+            # cancel should send response RequestCancelled
+            Solargraph::Logging.logger.info "Cancelled response to ##{id} #{method}"
+            set_result nil
+            set_error ErrorCodes::REQUEST_CANCELLED, 'Cancelled by client'
+          else
+            Solargraph::Logging.logger.info "Sending response to ##{id} #{method}"
+          end
+        end
       end
     end
   end

data/lib/solargraph/language_server/message/initialize.rb

@@ -174,7 +174,9 @@ module Solargraph
 
         # @param section [String]
         # @param capability [String]
-        # @return [Boolean]
+        # @todo Need support for RBS' boolish "type", which doesn't
+        #   enforce strict true/false-ness
+        # @sg-ignore
         def dynamic_registration_for? section, capability
           result = (params['capabilities'] &&
             params['capabilities'][section] &&

data/lib/solargraph/language_server/message/text_document/completion.rb

@@ -12,9 +12,6 @@ module Solargraph
             col = params['position']['character']
             begin
               completion = host.completions_at(params['textDocument']['uri'], line, col)
-              if host.cancel?(id)
-                return set_result(empty_result) if host.cancel?(id)
-              end
               items = []
               last_context = nil
               idx = -1

data/lib/solargraph/language_server/message/text_document/formatting.rb

@@ -33,6 +33,7 @@ module Solargraph
 
           private
 
+          # @param corrections [String]
           def log_corrections(corrections)
             corrections = corrections&.strip
             return if corrections&.empty?
@@ -51,6 +52,7 @@ module Solargraph
             conf['rubocop'] || {}
           end
 
+          # @param config [Hash{String => String}]
           def cli_args file_uri, config
             file = UriHelpers.uri_to_file(file_uri)
             args = [
@@ -68,6 +70,7 @@ module Solargraph
             args + [file]
           end
 
+          # @param config [Hash{String => String}]
           def formatter_class(config)
             if self.class.const_defined?('BlankRubocopFormatter')
               # @sg-ignore
@@ -79,6 +82,7 @@ module Solargraph
             end
           end
 
+          # @param value [Array, String]
           def cop_list(value)
             value = value.join(',') if value.respond_to?(:join)
             return nil if value == '' || !value.is_a?(String)