solargraph 0.58.0 → 0.58.2

data/lib/solargraph/pin/documenting.rb

@@ -1,114 +1,114 @@
-# frozen_string_literal: true
-
-require 'kramdown'
-require 'kramdown-parser-gfm'
-require 'yard'
-require 'reverse_markdown'
-require 'solargraph/converters/dl'
-require 'solargraph/converters/dt'
-require 'solargraph/converters/dd'
-require 'solargraph/converters/misc'
-
-# @todo upstream this definition
-
-# @!parse
-#   module ::Kramdown
-#     class Document
-#       # @return [String]
-#       def to_html; end
-#     end
-#   end
-#   module ReverseMarkdown
-#     # @param input [String]
-#     # @param options [Hash]
-#     # @return [String]
-#     def self.convert(input, options = {}); end
-#   end
-
-module Solargraph
-  module Pin
-    # A module to add the Pin::Base#documentation method.
-    #
-    module Documenting
-      # A documentation formatter that either performs Markdown conversion for
-      # text, or applies backticks for code blocks.
-      #
-      class DocSection
-        # @return [String]
-        attr_reader :plaintext
-
-        # @param code [Boolean] True if this section is a code block
-        def initialize code
-          @plaintext = String.new('')
-          @code = code
-        end
-
-        def code?
-          @code
-        end
-
-        # @param text [String]
-        # @return [String]
-        def concat text
-          @plaintext.concat text
-        end
-
-        def to_s
-          return to_code if code?
-          to_markdown
-        end
-
-        private
-
-        # @return [String]
-        def to_code
-          "\n```ruby\n#{Documenting.normalize_indentation(@plaintext)}#{@plaintext.end_with?("\n") ? '' : "\n"}```\n\n"
-        end
-
-        # @return [String]
-        def to_markdown
-          ReverseMarkdown.convert Kramdown::Document.new(@plaintext, input: 'GFM').to_html
-        end
-      end
-
-      # @return [String]
-      def documentation
-        @documentation ||= begin
-          # Using DocSections allows for code blocks that start with an empty
-          # line and at least two spaces of indentation. This is a common
-          # convention in Ruby core documentation, e.g., String#split.
-          sections = [DocSection.new(false)]
-          Documenting.normalize_indentation(Documenting.strip_html_comments(docstring.to_s.gsub("\t", '  '))).lines.each do |l|
-            if l.start_with?('  ')
-              # Code block
-              sections.push DocSection.new(true) unless sections.last.code?
-            elsif sections.last.code?
-              # Regular documentation
-              sections.push DocSection.new(false)
-            end
-            sections.last.concat l
-          end
-          sections.map(&:to_s).join.strip
-        end
-      end
-
-      # @param text [String]
-      # @return [String]
-      def self.strip_html_comments text
-        text.gsub(/<!--([\s\S]*?)-->/, '').strip
-      end
-
-      # @param text [String]
-      # @return [String]
-      def self.normalize_indentation text
-        left = text.lines.map do |line|
-          match = line.match(/^ +/)
-          next 0 unless match
-          match[0].length
-        end.min
-        return text if left.nil? || left.zero?
-        text.lines.map { |line| line[left..] }.join
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'kramdown'
+require 'kramdown-parser-gfm'
+require 'yard'
+require 'reverse_markdown'
+require 'solargraph/converters/dl'
+require 'solargraph/converters/dt'
+require 'solargraph/converters/dd'
+require 'solargraph/converters/misc'
+
+# @todo upstream this definition
+
+# @!parse
+#   module ::Kramdown
+#     class Document
+#       # @return [String]
+#       def to_html; end
+#     end
+#   end
+#   module ReverseMarkdown
+#     # @param input [String]
+#     # @param options [Hash]
+#     # @return [String]
+#     def self.convert(input, options = {}); end
+#   end
+
+module Solargraph
+  module Pin
+    # A module to add the Pin::Base#documentation method.
+    #
+    module Documenting
+      # A documentation formatter that either performs Markdown conversion for
+      # text, or applies backticks for code blocks.
+      #
+      class DocSection
+        # @return [String]
+        attr_reader :plaintext
+
+        # @param code [Boolean] True if this section is a code block
+        def initialize code
+          @plaintext = String.new('')
+          @code = code
+        end
+
+        def code?
+          @code
+        end
+
+        # @param text [String]
+        # @return [String]
+        def concat text
+          @plaintext.concat text
+        end
+
+        def to_s
+          return to_code if code?
+          to_markdown
+        end
+
+        private
+
+        # @return [String]
+        def to_code
+          "\n```ruby\n#{Documenting.normalize_indentation(@plaintext)}#{@plaintext.end_with?("\n") ? '' : "\n"}```\n\n"
+        end
+
+        # @return [String]
+        def to_markdown
+          ReverseMarkdown.convert Kramdown::Document.new(@plaintext, input: 'GFM').to_html
+        end
+      end
+
+      # @return [String]
+      def documentation
+        @documentation ||= begin
+          # Using DocSections allows for code blocks that start with an empty
+          # line and at least two spaces of indentation. This is a common
+          # convention in Ruby core documentation, e.g., String#split.
+          sections = [DocSection.new(false)]
+          Documenting.normalize_indentation(Documenting.strip_html_comments(docstring.to_s.gsub("\t", '  '))).lines.each do |l|
+            if l.start_with?('  ')
+              # Code block
+              sections.push DocSection.new(true) unless sections.last.code?
+            elsif sections.last.code?
+              # Regular documentation
+              sections.push DocSection.new(false)
+            end
+            sections.last.concat l
+          end
+          sections.map(&:to_s).join.strip
+        end
+      end
+
+      # @param text [String]
+      # @return [String]
+      def self.strip_html_comments text
+        text.gsub(/<!--([\s\S]*?)-->/, '').strip
+      end
+
+      # @param text [String]
+      # @return [String]
+      def self.normalize_indentation text
+        left = text.lines.map do |line|
+          match = line.match(/^ +/)
+          next 0 unless match
+          match[0].length
+        end.min
+        return text if left.nil? || left.zero?
+        text.lines.map { |line| line[left..] }.join
+      end
+    end
+  end
+end

data/lib/solargraph/pin/instance_variable.rb

@@ -1,34 +1,34 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class InstanceVariable < BaseVariable
-      # @return [ComplexType]
-      def binder
-        closure.binder
-      end
-
-      # @return [::Symbol]
-      def scope
-        closure.binder.scope
-      end
-
-      # @return [ComplexType]
-      def context
-        @context ||= begin
-          result = super
-          if scope == :class
-            ComplexType.parse("::Class<#{result.rooted_namespace}>")
-          else
-            result.reduce_class_type
-          end
-        end
-      end
-
-      # @param other [InstanceVariable]
-      def nearly? other
-        super && binder == other.binder
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class InstanceVariable < BaseVariable
+      # @return [ComplexType]
+      def binder
+        closure.binder
+      end
+
+      # @return [::Symbol]
+      def scope
+        closure.binder.scope
+      end
+
+      # @return [ComplexType]
+      def context
+        @context ||= begin
+          result = super
+          if scope == :class
+            ComplexType.parse("::Class<#{result.rooted_namespace}>")
+          else
+            result.reduce_class_type
+          end
+        end
+      end
+
+      # @param other [InstanceVariable]
+      def nearly? other
+        super && binder == other.binder
+      end
+    end
+  end
+end

data/lib/solargraph/pin/keyword.rb

@@ -1,20 +1,20 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class Keyword < Base
-      def initialize(name, **kwargs)
-        # @sg-ignore "Unrecognized keyword argument kwargs to Solargraph::Pin::Base#initialize"
-        super(name: name, **kwargs)
-      end
-
-      def closure
-        @closure ||= Pin::ROOT_PIN
-      end
-
-      def name
-        @name
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Keyword < Base
+      def initialize(name, **kwargs)
+        # @sg-ignore "Unrecognized keyword argument kwargs to Solargraph::Pin::Base#initialize"
+        super(name: name, **kwargs)
+      end
+
+      def closure
+        @closure ||= Pin::ROOT_PIN
+      end
+
+      def name
+        @name
+      end
+    end
+  end
+end

data/lib/solargraph/pin/local_variable.rb

@@ -1,75 +1,75 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class LocalVariable < BaseVariable
-      # @return [Range]
-      attr_reader :presence
-
-      def presence_certain?
-        @presence_certain
-      end
-
-      # @param assignment [AST::Node, nil]
-      # @param presence [Range, nil]
-      # @param presence_certain [Boolean]
-      # @param splat [Hash]
-      def initialize assignment: nil, presence: nil, presence_certain: false, **splat
-        super(**splat)
-        @assignment = assignment
-        @presence = presence
-        @presence_certain = presence_certain
-      end
-
-      def combine_with(other, attrs={})
-        new_attrs = {
-          assignment: assert_same(other, :assignment),
-          presence_certain: assert_same(other, :presence_certain?),
-        }.merge(attrs)
-        new_attrs[:presence] = assert_same(other, :presence) unless attrs.key?(:presence)
-
-        super(other, new_attrs)
-      end
-
-      # @param other_closure [Pin::Closure]
-      # @param other_loc [Location]
-      def visible_at?(other_closure, other_loc)
-        location.filename == other_loc.filename &&
-          presence.include?(other_loc.range.start) &&
-          match_named_closure(other_closure, closure)
-      end
-
-      def to_rbs
-        (name || '(anon)') + ' ' + (return_type&.to_rbs || 'untyped')
-      end
-
-      private
-
-      # @param tag1 [String]
-      # @param tag2 [String]
-      # @return [Boolean]
-      def match_tags tag1, tag2
-        # @todo This is an unfortunate hack made necessary by a discrepancy in
-        #   how tags indicate the root namespace. The long-term solution is to
-        #   standardize it, whether it's `Class<>`, an empty string, or
-        #   something else.
-        tag1 == tag2 ||
-          (['', 'Class<>'].include?(tag1) && ['', 'Class<>'].include?(tag2))
-      end
-
-      # @param needle [Pin::Base]
-      # @param haystack [Pin::Base]
-      # @return [Boolean]
-      def match_named_closure needle, haystack
-        return true if needle == haystack || haystack.is_a?(Pin::Block)
-        cursor = haystack
-        until cursor.nil?
-          return true if needle.path == cursor.path
-          return false if cursor.path && !cursor.path.empty?
-          cursor = cursor.closure
-        end
-        false
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class LocalVariable < BaseVariable
+      # @return [Range]
+      attr_reader :presence
+
+      def presence_certain?
+        @presence_certain
+      end
+
+      # @param assignment [AST::Node, nil]
+      # @param presence [Range, nil]
+      # @param presence_certain [Boolean]
+      # @param splat [Hash]
+      def initialize assignment: nil, presence: nil, presence_certain: false, **splat
+        super(**splat)
+        @assignment = assignment
+        @presence = presence
+        @presence_certain = presence_certain
+      end
+
+      def combine_with(other, attrs={})
+        new_attrs = {
+          assignment: assert_same(other, :assignment),
+          presence_certain: assert_same(other, :presence_certain?),
+        }.merge(attrs)
+        new_attrs[:presence] = assert_same(other, :presence) unless attrs.key?(:presence)
+
+        super(other, new_attrs)
+      end
+
+      # @param other_closure [Pin::Closure]
+      # @param other_loc [Location]
+      def visible_at?(other_closure, other_loc)
+        location.filename == other_loc.filename &&
+          presence.include?(other_loc.range.start) &&
+          match_named_closure(other_closure, closure)
+      end
+
+      def to_rbs
+        (name || '(anon)') + ' ' + (return_type&.to_rbs || 'untyped')
+      end
+
+      private
+
+      # @param tag1 [String]
+      # @param tag2 [String]
+      # @return [Boolean]
+      def match_tags tag1, tag2
+        # @todo This is an unfortunate hack made necessary by a discrepancy in
+        #   how tags indicate the root namespace. The long-term solution is to
+        #   standardize it, whether it's `Class<>`, an empty string, or
+        #   something else.
+        tag1 == tag2 ||
+          (['', 'Class<>'].include?(tag1) && ['', 'Class<>'].include?(tag2))
+      end
+
+      # @param needle [Pin::Base]
+      # @param haystack [Pin::Base]
+      # @return [Boolean]
+      def match_named_closure needle, haystack
+        return true if needle == haystack || haystack.is_a?(Pin::Block)
+        cursor = haystack
+        until cursor.nil?
+          return true if needle.path == cursor.path
+          return false if cursor.path && !cursor.path.empty?
+          cursor = cursor.closure
+        end
+        false
+      end
+    end
+  end
+end