solargraph 0.56.0 → 0.58.2

data/lib/solargraph/environ.rb

@@ -13,16 +13,21 @@ module Solargraph
     # @return [Array<String>]
     attr_reader :domains
 
-    # @return [Array<Pin::Reference::Override>]
+    # @return [Array<Pin::Base>]
     attr_reader :pins
 
+    # @return [Array<String>]
+    attr_reader :yard_plugins
+
     # @param requires [Array<String>]
     # @param domains [Array<String>]
     # @param pins [Array<Pin::Base>]
-    def initialize requires: [], domains: [], pins: []
+    # @param yard_plugins [Array<String>]
+    def initialize requires: [], domains: [], pins: [], yard_plugins: []
       @requires = requires
       @domains = domains
       @pins = pins
+      @yard_plugins = yard_plugins
     end
 
     # @return [self]
@@ -30,6 +35,7 @@ module Solargraph
       domains.clear
       requires.clear
       pins.clear
+      yard_plugins.clear
       self
     end
 
@@ -39,6 +45,7 @@ module Solargraph
       domains.concat other.domains
       requires.concat other.requires
       pins.concat other.pins
+      yard_plugins.concat other.yard_plugins
       self
     end
   end

data/lib/solargraph/equality.rb

@@ -1,33 +1,34 @@
-# 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
+# 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) &&
+        # @sg-ignore https://github.com/castwide/solargraph/pull/1114
+        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/gem_pins.rb

@@ -1,88 +1,98 @@
-# frozen_string_literal: true
-
-require 'rbs'
-
-module Solargraph
-  # A utility for building gem pins from a combination of YARD and RBS
-  # documentation.
-  #
-  module GemPins
-    class << self
-      include Logging
-    end
-
-    # @param gemspec [Gem::Specification]
-    # @return [Array<Pin::Base>]
-    def self.build_yard_pins(gemspec)
-      Yardoc.cache(gemspec) unless Yardoc.cached?(gemspec)
-      yardoc = Yardoc.load!(gemspec)
-      YardMap::Mapper.new(yardoc, gemspec).map
-    end
-
-    # @param pins [Array<Pin::Base>]
-    def self.combine_method_pins_by_path(pins)
-      # bad_pins = pins.select { |pin| pin.is_a?(Pin::Method) && pin.path == 'StringIO.open' && pin.source == :rbs }; raise "wtf: #{bad_pins}" if bad_pins.length > 1
-      method_pins, alias_pins = pins.partition { |pin| pin.class == Pin::Method }
-      by_path = method_pins.group_by(&:path)
-      by_path.transform_values! do |pins|
-        GemPins.combine_method_pins(*pins)
-      end
-      by_path.values + alias_pins
-    end
-
-    def self.combine_method_pins(*pins)
-      out = pins.reduce(nil) do |memo, pin|
-        next pin if memo.nil?
-        if memo == pin && memo.source != :combined
-          # @todo we should track down situations where we are handled
-          #   the same pin from the same source here and eliminate them -
-          #   this is an efficiency workaround for now
-          next memo
-        end
-        memo.combine_with(pin)
-      end
-      logger.debug { "GemPins.combine_method_pins(pins.length=#{pins.length}, pins=#{pins}) => #{out.inspect}" }
-      out
-    end
-
-    # @param yard_pins [Array<Pin::Base>]
-    # @param rbs_map [RbsMap]
-    # @return [Array<Pin::Base>]
-    def self.combine(yard_pins, rbs_pins)
-      in_yard = Set.new
-      rbs_api_map = Solargraph::ApiMap.new(pins: rbs_pins)
-      combined = yard_pins.map do |yard_pin|
-        in_yard.add yard_pin.path
-        rbs_pin = rbs_api_map.get_path_pins(yard_pin.path).filter { |pin| pin.is_a? Pin::Method }.first
-        next yard_pin unless rbs_pin && yard_pin.class == Pin::Method
-
-        unless rbs_pin
-          logger.debug { "GemPins.combine: No rbs pin for #{yard_pin.path} - using YARD's '#{yard_pin.inspect} (return_type=#{yard_pin.return_type}; signatures=#{yard_pin.signatures})" }
-          next yard_pin
-        end
-
-        out = combine_method_pins(rbs_pin, yard_pin)
-        logger.debug { "GemPins.combine: Combining yard.path=#{yard_pin.path} - rbs=#{rbs_pin.inspect} with yard=#{yard_pin.inspect} into #{out}" }
-        out
-      end
-      in_rbs_only = rbs_pins.select do |pin|
-        pin.path.nil? || !in_yard.include?(pin.path)
-      end
-      out = combined + in_rbs_only
-      logger.debug { "GemPins#combine: Returning #{out.length} combined pins" }
-      out
-    end
-
-    class << self
-      private
-
-      # Select the first defined type.
-      #
-      # @param choices [Array<ComplexType>]
-      # @return [ComplexType]
-      def best_return_type *choices
-        choices.find { |pin| pin.defined? } || choices.first || ComplexType::UNDEFINED
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'rbs'
+
+module Solargraph
+  # A utility for building gem pins from a combination of YARD and RBS
+  # documentation.
+  #
+  module GemPins
+    class << self
+      include Logging
+    end
+
+    # @param pins [Array<Pin::Base>]
+    # @return [Array<Pin::Base>]
+    def self.combine_method_pins_by_path(pins)
+      method_pins, alias_pins = pins.partition { |pin| pin.class == Pin::Method }
+      by_path = method_pins.group_by(&:path)
+      by_path.transform_values! do |pins|
+        GemPins.combine_method_pins(*pins)
+      end
+      by_path.values + alias_pins
+    end
+
+    # @param pins [Array<Pin::Method>]
+    # @return [Pin::Method, nil]
+    def self.combine_method_pins(*pins)
+      # @type [Pin::Method, nil]
+      combined_pin = nil
+      # @param memo [Pin::Method, nil]
+      # @param pin [Pin::Method]
+      out = pins.reduce(combined_pin) do |memo, pin|
+        next pin if memo.nil?
+        if memo == pin && memo.source != :combined
+          # @todo we should track down situations where we are handled
+          #   the same pin from the same source here and eliminate them -
+          #   this is an efficiency workaround for now
+          next memo
+        end
+        memo.combine_with(pin)
+      end
+      logger.debug { "GemPins.combine_method_pins(pins.length=#{pins.length}, pins=#{pins}) => #{out.inspect}" }
+      out
+    end
+
+    # @param yard_plugins [Array<String>] The names of YARD plugins to use.
+    # @param gemspec [Gem::Specification]
+    # @return [Array<Pin::Base>]
+    def self.build_yard_pins(yard_plugins, gemspec)
+      Yardoc.cache(yard_plugins, gemspec) unless Yardoc.cached?(gemspec)
+      return [] unless Yardoc.cached?(gemspec)
+      yardoc = Yardoc.load!(gemspec)
+      YardMap::Mapper.new(yardoc, gemspec).map
+    end
+
+    # @param yard_pins [Array<Pin::Base>]
+    # @param rbs_pins [Array<Pin::Base>]
+    #
+    # @return [Array<Pin::Base>]
+    def self.combine(yard_pins, rbs_pins)
+      in_yard = Set.new
+      rbs_api_map = Solargraph::ApiMap.new(pins: rbs_pins)
+      combined = yard_pins.map do |yard_pin|
+        in_yard.add yard_pin.path
+        rbs_pin = rbs_api_map.get_path_pins(yard_pin.path).filter { |pin| pin.is_a? Pin::Method }.first
+        next yard_pin unless rbs_pin && yard_pin.class == Pin::Method
+
+        unless rbs_pin
+          # @sg-ignore https://github.com/castwide/solargraph/pull/1114
+          logger.debug { "GemPins.combine: No rbs pin for #{yard_pin.path} - using YARD's '#{yard_pin.inspect} (return_type=#{yard_pin.return_type}; signatures=#{yard_pin.signatures})" }
+          next yard_pin
+        end
+
+        out = combine_method_pins(rbs_pin, yard_pin)
+        logger.debug { "GemPins.combine: Combining yard.path=#{yard_pin.path} - rbs=#{rbs_pin.inspect} with yard=#{yard_pin.inspect} into #{out}" }
+        out
+      end
+      in_rbs_only = rbs_pins.select do |pin|
+        pin.path.nil? || !in_yard.include?(pin.path)
+      end
+      out = combined + in_rbs_only
+      logger.debug { "GemPins#combine: Returning #{out.length} combined pins" }
+      out
+    end
+
+    class << self
+      private
+
+      # Select the first defined type.
+      #
+      # @param choices [Array<ComplexType>]
+      # @return [ComplexType]
+      def best_return_type *choices
+        choices.find { |pin| pin.defined? } || choices.first || ComplexType::UNDEFINED
+      end
+    end
+  end
+end

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

@@ -1,89 +1,89 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module LanguageServer
-    class Host
-      # An asynchronous diagnosis reporter.
-      #
-      class Diagnoser
-        # @param host [Host]
-        def initialize host
-          @host = host
-          @mutex = Mutex.new
-          @queue = []
-          @stopped = true
-        end
-
-        # Schedule a file to be diagnosed.
-        #
-        # @param uri [String]
-        # @return [void]
-        def schedule uri
-          mutex.synchronize { queue.push uri }
-        end
-
-        # Stop the diagnosis thread.
-        #
-        # @return [void]
-        def stop
-          @stopped = true
-        end
-
-        # True is the diagnoser is stopped.
-        #
-        # @return [Boolean]
-        def stopped?
-          @stopped
-        end
-
-        # Start the diagnosis thread.
-        #
-        # @return [self, nil]
-        def start
-          return unless @stopped
-          @stopped = false
-          Thread.new do
-            until stopped?
-              tick
-              sleep 0.1
-            end
-          end
-          self
-        end
-
-        # Perform diagnoses.
-        #
-        # @return [void]
-        def tick
-          return if queue.empty? || host.synchronizing?
-          if !host.options['diagnostics']
-            mutex.synchronize { queue.clear }
-            return
-          end
-          current = mutex.synchronize { queue.shift }
-          return if queue.include?(current)
-          begin
-            host.diagnose current
-          rescue InvalidOffsetError
-            # @todo This error can occur when the Source is out of sync with
-            #   with the ApiMap. It's probably not the best way to handle it,
-            #   but it's quick and easy.
-            Logging.logger.warn "Deferring diagnosis due to invalid offset: #{current}"
-            mutex.synchronize { queue.push current }
-          end
-        end
-
-        private
-
-        # @return [Host]
-        attr_reader :host
-
-        # @return [Mutex]
-        attr_reader :mutex
-
-        # @return [::Array]
-        attr_reader :queue
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module LanguageServer
+    class Host
+      # An asynchronous diagnosis reporter.
+      #
+      class Diagnoser
+        # @param host [Host]
+        def initialize host
+          @host = host
+          @mutex = Mutex.new
+          @queue = []
+          @stopped = true
+        end
+
+        # Schedule a file to be diagnosed.
+        #
+        # @param uri [String]
+        # @return [void]
+        def schedule uri
+          mutex.synchronize { queue.push uri }
+        end
+
+        # Stop the diagnosis thread.
+        #
+        # @return [void]
+        def stop
+          @stopped = true
+        end
+
+        # True is the diagnoser is stopped.
+        #
+        # @return [Boolean]
+        def stopped?
+          @stopped
+        end
+
+        # Start the diagnosis thread.
+        #
+        # @return [self, nil]
+        def start
+          return unless @stopped
+          @stopped = false
+          Thread.new do
+            until stopped?
+              tick
+              sleep 0.1
+            end
+          end
+          self
+        end
+
+        # Perform diagnoses.
+        #
+        # @return [void]
+        def tick
+          return if queue.empty? || host.synchronizing?
+          if !host.options['diagnostics']
+            mutex.synchronize { queue.clear }
+            return
+          end
+          current = mutex.synchronize { queue.shift }
+          return if queue.include?(current)
+          begin
+            host.diagnose current
+          rescue InvalidOffsetError
+            # @todo This error can occur when the Source is out of sync with
+            #   with the ApiMap. It's probably not the best way to handle it,
+            #   but it's quick and easy.
+            Logging.logger.warn "Deferring diagnosis due to invalid offset: #{current}"
+            mutex.synchronize { queue.push current }
+          end
+        end
+
+        private
+
+        # @return [Host]
+        attr_reader :host
+
+        # @return [Mutex]
+        attr_reader :mutex
+
+        # @return [::Array]
+        attr_reader :queue
+      end
+    end
+  end
+end