solargraph 0.57.0 → 0.58.3

data/lib/solargraph/pin/reference/override.rb

@@ -1,47 +1,47 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class Reference
-      class Override < Reference
-        # @return [::Array<YARD::Tags::Tag>]
-        attr_reader :tags
-
-        # @return [::Array<Symbol>]
-        attr_reader :delete
-
-        def closure
-          nil
-        end
-
-        # @param location [Location, nil]
-        # @param name [String]
-        # @param tags [::Array<YARD::Tags::Tag>]
-        # @param delete [::Array<Symbol>]
-        # @param splat [Hash]
-        def initialize location, name, tags, delete = [], **splat
-          super(location: location, name: name, **splat)
-          @tags = tags
-          @delete = delete
-        end
-
-        # @param name [String]
-        # @param tags [::Array<String>]
-        # @param delete [::Array<Symbol>]
-        # @param splat [Hash]
-        # @return [Solargraph::Pin::Reference::Override]
-        def self.method_return name, *tags, delete: [], **splat
-          new(nil, name, [YARD::Tags::Tag.new('return', '', tags)], delete, **splat)
-        end
-
-        # @param name [String]
-        # @param comment [String]
-        # @param splat [Hash]
-        # @return [Solargraph::Pin::Reference::Override]
-        def self.from_comment name, comment, **splat
-          new(nil, name, Solargraph::Source.parse_docstring(comment).to_docstring.tags, **splat)
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Reference
+      class Override < Reference
+        # @return [::Array<YARD::Tags::Tag>]
+        attr_reader :tags
+
+        # @return [::Array<Symbol>]
+        attr_reader :delete
+
+        def closure
+          nil
+        end
+
+        # @param location [Location, nil]
+        # @param name [String]
+        # @param tags [::Array<YARD::Tags::Tag>]
+        # @param delete [::Array<Symbol>]
+        # @param splat [Hash]
+        def initialize location, name, tags, delete = [], **splat
+          super(location: location, name: name, **splat)
+          @tags = tags
+          @delete = delete
+        end
+
+        # @param name [String]
+        # @param tags [::Array<String>]
+        # @param delete [::Array<Symbol>]
+        # @param splat [Hash]
+        # @return [Solargraph::Pin::Reference::Override]
+        def self.method_return name, *tags, delete: [], **splat
+          new(nil, name, [YARD::Tags::Tag.new('return', '', tags)], delete, **splat)
+        end
+
+        # @param name [String]
+        # @param comment [String]
+        # @param splat [Hash]
+        # @return [Solargraph::Pin::Reference::Override]
+        def self.from_comment name, comment, **splat
+          new(nil, name, Solargraph::Source.parse_docstring(comment).to_docstring.tags, **splat)
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/pin/reference/superclass.rb

@@ -1,15 +1,15 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class Reference
-      # A Superclass reference pin.
-      #
-      class Superclass < Reference
-        def reference_gates
-          @reference_gates ||= closure.gates - [closure.path]
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Reference
+      # A Superclass reference pin.
+      #
+      class Superclass < Reference
+        def reference_gates
+          @reference_gates ||= closure.gates - [closure.path]
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/pin/reference.rb

@@ -1,48 +1,39 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class Reference < Base
-      autoload :Require,    'solargraph/pin/reference/require'
-      autoload :Superclass, 'solargraph/pin/reference/superclass'
-      autoload :Include,    'solargraph/pin/reference/include'
-      autoload :Prepend,    'solargraph/pin/reference/prepend'
-      autoload :Extend,     'solargraph/pin/reference/extend'
-      autoload :Override,   'solargraph/pin/reference/override'
-
-      attr_reader :generic_values
-
-      # @param generic_values [Array<String>]
-      def initialize generic_values: [], **splat
-        super(**splat)
-        @generic_values = generic_values
-      end
-
-      # @return [String]
-      def parameter_tag
-        @parameter_tag ||= if generic_values&.any?
-                             "<#{generic_values.join(', ')}>"
-                           else
-                             ''
-                           end
-      end
-
-      # @return [ComplexType]
-      def parametrized_tag
-        @parametrized_tag ||= ComplexType.try_parse(
-          name +
-          if generic_values&.length&.> 0
-            "<#{generic_values.join(', ')}>"
-          else
-            ''
-          end
-        )
-      end
-
-      # @return [Array<String>]
-      def reference_gates
-        closure.gates
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Reference < Base
+      autoload :Require,    'solargraph/pin/reference/require'
+      autoload :Superclass, 'solargraph/pin/reference/superclass'
+      autoload :Include,    'solargraph/pin/reference/include'
+      autoload :Prepend,    'solargraph/pin/reference/prepend'
+      autoload :Extend,     'solargraph/pin/reference/extend'
+      autoload :Override,   'solargraph/pin/reference/override'
+
+      attr_reader :generic_values
+
+      # @param generic_values [Array<String>]
+      def initialize generic_values: [], **splat
+        super(**splat)
+        @generic_values = generic_values
+      end
+
+      # @return [ComplexType]
+      def type
+        @type ||= ComplexType.try_parse(
+          name +
+          if generic_values&.length&.> 0
+            "<#{generic_values.join(', ')}>"
+          else
+            ''
+          end
+        )
+      end
+
+      # @return [Array<String>]
+      def reference_gates
+        closure.gates
+      end
+    end
+  end
+end

data/lib/solargraph/pin/search.rb

@@ -1,58 +1,61 @@
-# 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
-
-        # @param match [Float] The match score for the pin
-        # @param pin [Pin::Base]
-        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.similarity(str1, str2, ignore_case: true)
-      end
-    end
-  end
-end
+# 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
+
+        # @param match [Float] The match score for the pin
+        # @param pin [Pin::Base]
+        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
+          # @param a [self]
+          # @param b [self]
+          # @sg-ignore https://github.com/castwide/solargraph/pull/1050
+          .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.similarity(str1, str2, ignore_case: true)
+      end
+    end
+  end
+end

data/lib/solargraph/pin/signature.rb

@@ -1,61 +1,61 @@
-module Solargraph
-  module Pin
-    class Signature < Callable
-      # allow signature to be created before method pin, then set this
-      # to the method pin
-      attr_writer :closure
-
-      def initialize **splat
-        super(**splat)
-      end
-
-      def generics
-        @generics ||= [].freeze
-      end
-
-      def identity
-        @identity ||= "signature#{object_id}"
-      end
-
-      attr_writer :closure
-
-      def dodgy_return_type_source?
-        super || closure&.dodgy_return_type_source?
-      end
-
-      def type_location
-        super || closure&.type_location
-      end
-
-      def location
-        super || closure&.location
-      end
-
-      def typify api_map
-        if return_type.defined?
-          qualified = return_type.qualify(api_map, closure.namespace)
-          logger.debug { "Signature#typify(self=#{self}) => #{qualified.rooted_tags.inspect}" }
-          return qualified
-        end
-        return ComplexType::UNDEFINED if closure.nil?
-        return ComplexType::UNDEFINED unless closure.is_a?(Pin::Method)
-        # @sg-ignore need is_a? support
-        # @type [Array<Pin::Method>]
-        method_stack = closure.rest_of_stack api_map
-        logger.debug { "Signature#typify(self=#{self}) - method_stack: #{method_stack}" }
-        method_stack.each do |pin|
-          sig = pin.signatures.find { |s| s.arity == self.arity }
-          next unless sig
-          unless sig.return_type.undefined?
-            qualified = sig.return_type.qualify(api_map, closure.namespace)
-            logger.debug { "Signature#typify(self=#{self}) => #{qualified.rooted_tags.inspect}" }
-            return qualified
-          end
-        end
-        out = super
-        logger.debug { "Signature#typify(self=#{self}) => #{out}" }
-        out
-      end
-    end
-  end
-end
+module Solargraph
+  module Pin
+    class Signature < Callable
+      # allow signature to be created before method pin, then set this
+      # to the method pin
+      attr_writer :closure
+
+      def initialize **splat
+        super(**splat)
+      end
+
+      def generics
+        @generics ||= [].freeze
+      end
+
+      def identity
+        @identity ||= "signature#{object_id}"
+      end
+
+      attr_writer :closure
+
+      def dodgy_return_type_source?
+        super || closure&.dodgy_return_type_source?
+      end
+
+      def type_location
+        super || closure&.type_location
+      end
+
+      def location
+        super || closure&.location
+      end
+
+      def typify api_map
+        if return_type.defined?
+          qualified = return_type.qualify(api_map, closure.namespace)
+          logger.debug { "Signature#typify(self=#{self}) => #{qualified.rooted_tags.inspect}" }
+          return qualified
+        end
+        return ComplexType::UNDEFINED if closure.nil?
+        return ComplexType::UNDEFINED unless closure.is_a?(Pin::Method)
+        # @sg-ignore need is_a? support
+        # @type [Array<Pin::Method>]
+        method_stack = closure.rest_of_stack api_map
+        logger.debug { "Signature#typify(self=#{self}) - method_stack: #{method_stack}" }
+        method_stack.each do |pin|
+          sig = pin.signatures.find { |s| s.arity == self.arity }
+          next unless sig
+          unless sig.return_type.undefined?
+            qualified = sig.return_type.qualify(api_map, closure.namespace)
+            logger.debug { "Signature#typify(self=#{self}) => #{qualified.rooted_tags.inspect}" }
+            return qualified
+          end
+        end
+        out = super
+        logger.debug { "Signature#typify(self=#{self}) => #{out}" }
+        out
+      end
+    end
+  end
+end

data/lib/solargraph/pin/symbol.rb

@@ -1,53 +1,53 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class Symbol < Base
-      # @param location [Solargraph::Location]
-      # @param name [String]
-      def initialize(location, name, **kwargs)
-        # @sg-ignore "Unrecognized keyword argument kwargs to Solargraph::Pin::Base#initialize"
-        super(location: location, name: name, **kwargs)
-        # @name = name
-        # @location = location
-      end
-
-      def namespace
-        ''
-      end
-
-      def path
-        ''
-      end
-
-      def closure
-        @closure ||= Pin::ROOT_PIN
-      end
-
-      def completion_item_kind
-        Solargraph::LanguageServer::CompletionItemKinds::KEYWORD
-      end
-
-      def comments
-        ''
-      end
-
-      def return_type
-        @return_type ||= Solargraph::ComplexType::SYMBOL
-      end
-
-      def directives
-        []
-      end
-
-      # @return [::Symbol]
-      def visibility
-        :public
-      end
-
-      def deprecated?
-        false
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Symbol < Base
+      # @param location [Solargraph::Location]
+      # @param name [String]
+      def initialize(location, name, **kwargs)
+        # @sg-ignore "Unrecognized keyword argument kwargs to Solargraph::Pin::Base#initialize"
+        super(location: location, name: name, **kwargs)
+        # @name = name
+        # @location = location
+      end
+
+      def namespace
+        ''
+      end
+
+      def path
+        ''
+      end
+
+      def closure
+        @closure ||= Pin::ROOT_PIN
+      end
+
+      def completion_item_kind
+        Solargraph::LanguageServer::CompletionItemKinds::KEYWORD
+      end
+
+      def comments
+        ''
+      end
+
+      def return_type
+        @return_type ||= Solargraph::ComplexType::SYMBOL
+      end
+
+      def directives
+        []
+      end
+
+      # @return [::Symbol]
+      def visibility
+        :public
+      end
+
+      def deprecated?
+        false
+      end
+    end
+  end
+end

data/lib/solargraph/pin/until.rb

@@ -1,18 +1,18 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class Until < Base
-      include Breakable
-
-      # @param receiver [Parser::AST::Node, nil]
-      # @param node [Parser::AST::Node, nil]
-      # @param context [ComplexType, nil]
-      # @param args [::Array<Parameter>]
-      def initialize node: nil, **splat
-        super(**splat)
-        @node = node
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Until < Base
+      include Breakable
+
+      # @param receiver [Parser::AST::Node, nil]
+      # @param node [Parser::AST::Node, nil]
+      # @param context [ComplexType, nil]
+      # @param args [::Array<Parameter>]
+      def initialize node: nil, **splat
+        super(**splat)
+        @node = node
+      end
+    end
+  end
+end

data/lib/solargraph/pin/while.rb

@@ -1,18 +1,18 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class While < Base
-      include Breakable
-
-      # @param receiver [Parser::AST::Node, nil]
-      # @param node [Parser::AST::Node, nil]
-      # @param context [ComplexType, nil]
-      # @param args [::Array<Parameter>]
-      def initialize node: nil, **splat
-        super(**splat)
-        @node = node
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class While < Base
+      include Breakable
+
+      # @param receiver [Parser::AST::Node, nil]
+      # @param node [Parser::AST::Node, nil]
+      # @param context [ComplexType, nil]
+      # @param args [::Array<Parameter>]
+      def initialize node: nil, **splat
+        super(**splat)
+        @node = node
+      end
+    end
+  end
+end