cosmicgraph 0.49.0

data/lib/solargraph/pin/parameter.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Parameter < LocalVariable
+      # @return [Symbol]
+      attr_reader :decl
+
+      # @return [String]
+      attr_reader :asgn_code
+
+      def initialize decl: :arg, asgn_code: nil, return_type: nil, **splat
+        super(**splat)
+        @asgn_code = asgn_code
+        @decl = decl
+        @return_type = return_type
+      end
+
+      def keyword?
+        [:kwarg, :kwoptarg].include?(decl)
+      end
+
+      def kwrestarg?
+        decl == :kwrestarg || (assignment && [:HASH, :hash].include?(assignment.type))
+      end
+
+      def restarg?
+        decl == :restarg
+      end
+
+      def rest?
+        decl == :restarg || decl == :kwrestarg
+      end
+
+      def block?
+        [:block, :blockarg].include?(decl)
+      end
+
+      def full
+        case decl
+        when :optarg
+          "#{name} = #{asgn_code || '?'}"
+        when :kwarg
+          "#{name}:"
+        when :kwoptarg
+          "#{name}: #{asgn_code || '?'}"
+        when :restarg
+          "*#{name}"
+        when :kwrestarg
+          "**#{name}"
+        when :block, :blockarg
+          "&#{name}"
+        else
+          name
+        end
+      end
+
+      def return_type
+        if @return_type.nil?
+          @return_type = ComplexType::UNDEFINED
+          found = param_tag
+          @return_type = ComplexType.try_parse(*found.types) unless found.nil? or found.types.nil?
+          if @return_type.undefined?
+            if decl == :restarg
+              @return_type = ComplexType.try_parse('Array')
+            elsif decl == :kwrestarg
+              @return_type = ComplexType.try_parse('Hash')
+            elsif decl == :blockarg
+              @return_type = ComplexType.try_parse('Proc')
+            end
+          end
+        end
+        super
+        @return_type
+      end
+
+      # The parameter's zero-based location in the block's signature.
+      #
+      # @return [Integer]
+      def index
+        closure.parameter_names.index(name)
+      end
+
+      # @param api_map [ApiMap]
+      def typify api_map
+        return return_type.qualify(api_map, closure.context.namespace) unless return_type.undefined?
+        closure.is_a?(Pin::Block) ? typify_block_param(api_map) : typify_method_param(api_map)
+      end
+
+      def documentation
+        tag = param_tag
+        return '' if tag.nil? || tag.text.nil?
+        tag.text
+      end
+
+      def try_merge! pin
+        return false unless super && closure == pin.closure
+        true
+      end
+
+      private
+
+      # @return [YARD::Tags::Tag]
+      def param_tag
+        found = nil
+        params = closure.docstring.tags(:param)
+        params.each do |p|
+          next unless p.name == name
+          found = p
+          break
+        end
+        if found.nil? and !index.nil?
+          found = params[index] if params[index] && (params[index].name.nil? || params[index].name.empty?)
+        end
+        found
+      end
+
+      # @param api_map [ApiMap]
+      # @return [ComplexType]
+      def typify_block_param api_map
+        if closure.is_a?(Pin::Block) && closure.receiver
+          chain = Parser.chain(closure.receiver, filename)
+          clip = api_map.clip_at(location.filename, location.range.start)
+          locals = clip.locals - [self]
+          meths = chain.define(api_map, closure, locals)
+          meths.each do |meth|
+            if meth.docstring.has_tag?(:yieldparam_single_parameter)
+              type = chain.base.infer(api_map, closure, locals)
+              if type.defined? && !type.subtypes.empty?
+                bmeth = chain.base.define(api_map, closure, locals).first
+                return type.subtypes.first.qualify(api_map, bmeth.context.namespace)
+              end
+            else
+              yps = meth.docstring.tags(:yieldparam)
+              unless yps[index].nil? or yps[index].types.nil? or yps[index].types.empty?
+                return ComplexType.try_parse(yps[index].types.first).self_to(chain.base.infer(api_map, closure, locals).namespace).qualify(api_map, meth.context.namespace)
+              end
+            end
+          end
+        end
+        ComplexType::UNDEFINED
+      end
+
+      # @param api_map [ApiMap]
+      # @return [ComplexType]
+      def typify_method_param api_map
+        meths = api_map.get_method_stack(closure.full_context.namespace, closure.name, scope: closure.scope)
+        # meths.shift # Ignore the first one
+        meths.each do |meth|
+          found = nil
+          params = meth.docstring.tags(:param) + see_reference(docstring, api_map)
+          params.each do |p|
+            next unless p.name == name
+            found = p
+            break
+          end
+          if found.nil? and !index.nil?
+            found = params[index] if params[index] && (params[index].name.nil? || params[index].name.empty?)
+          end
+          return ComplexType.try_parse(*found.types).qualify(api_map, meth.context.namespace) unless found.nil? || found.types.nil?
+        end
+        ComplexType::UNDEFINED
+      end
+
+      # @param heredoc [YARD::Docstring]
+      # @param api_map [ApiMap]
+      # @param skip [Array]
+      # @return [Array<YARD::Tags::Tag>]
+      def see_reference heredoc, api_map, skip = []
+        heredoc.ref_tags.each do |ref|
+          next unless ref.tag_name == 'param' && ref.owner
+          result = resolve_reference(ref.owner.to_s, api_map, skip)
+          return result unless result.nil?
+        end
+        []
+      end
+
+      # @param ref [String]
+      # @param api_map [ApiMap]
+      # @param skip [Array]
+      # @return [Array<YARD::Tags::Tag>, nil]
+      def resolve_reference ref, api_map, skip
+        return nil if skip.include?(ref)
+        skip.push ref
+        parts = ref.split(/[\.#]/)
+        if parts.first.empty?
+          path = "#{namespace}#{ref}"
+        else
+          fqns = api_map.qualify(parts.first, namespace)
+          return nil if fqns.nil?
+          path = fqns + ref[parts.first.length] + parts.last
+        end
+        pins = api_map.get_path_pins(path)
+        pins.each do |pin|
+          params = pin.docstring.tags(:param)
+          return params unless params.empty?
+        end
+        pins.each do |pin|
+          params = see_reference(pin.docstring, api_map, skip)
+          return params unless params.empty?
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/solargraph/pin/proxy_type.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class ProxyType < Base
+      # @param return_type [ComplexType]
+      def initialize return_type: ComplexType::UNDEFINED, **splat
+        super(**splat)
+        @return_type = return_type
+      end
+
+      def context
+        @return_type
+      end
+
+      # @param return_type [ComplexType]
+      # @return [ProxyType]
+      def self.anonymous return_type
+        parts = return_type.namespace.split('::')
+        namespace = parts[0..-2].join('::').to_s
+        name = parts.last.to_s
+        # ProxyType.new(nil, namespace, name, return_type)
+        ProxyType.new(
+          closure: Solargraph::Pin::Namespace.new(name: namespace), return_type: return_type
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Reference
+      class Extend < Reference
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Reference
+      class Include < Reference
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# 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 initialize location, name, tags, delete = []
+          super(location: location, name: name)
+          @tags = tags
+          @delete = delete
+        end
+
+        def self.method_return name, *tags, delete: []
+          new(nil, name, [YARD::Tags::Tag.new('return', nil, tags)], delete)
+        end
+
+        def self.from_comment name, comment
+          new(nil, name, Solargraph::Source.parse_docstring(comment).to_docstring.tags)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Reference
+      class Prepend < Reference
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Reference
+      class Require < Reference
+        def initialize location, name
+          # super(location, '', name)
+          super(location: location, name: name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Reference
+      class Superclass < Reference
+      end
+    end
+  end
+end

data/lib/solargraph/pin/reference.rb

@@ -0,0 +1,14 @@
+# 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'
+    end
+  end
+end

data/lib/solargraph/pin/search.rb

@@ -0,0 +1,56 @@
+# 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
+
+        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.distance(str1, str2, ignore_case: true)
+      end
+    end
+  end
+end

data/lib/solargraph/pin/signature.rb

@@ -0,0 +1,23 @@
+module Solargraph
+  module Pin
+    class Signature
+      # @return [Array<Parameter>]
+      attr_reader :parameters
+
+      # @return [ComplexType]
+      attr_reader :return_type
+
+      attr_reader :block
+
+      def initialize parameters, return_type, block = nil
+        @parameters = parameters
+        @return_type = return_type
+        @block = block
+      end
+
+      def block?
+        !!@block
+      end
+    end
+  end
+end

data/lib/solargraph/pin/singleton.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Singleton < Closure
+      def initialize name: '', location: nil, closure: nil
+        super
+      end
+    end
+  end
+end

data/lib/solargraph/pin/symbol.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Symbol < Base
+      # @param location [Solargraph::Location]
+      # @param name [String]
+      def initialize location, name
+        super(location: location, name: name)
+        # @name = name
+        # @location = location
+      end
+
+      def namespace
+        ''
+      end
+
+      def path
+        ''
+      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
+
+      def visibility
+        :public
+      end
+
+      def deprecated?
+        false
+      end
+    end
+  end
+end

data/lib/solargraph/pin.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'yard'
+
+module Solargraph
+  # The namespace for pins used in maps.
+  #
+  module Pin
+    autoload :Common,           'solargraph/pin/common'
+    autoload :Conversions,      'solargraph/pin/conversions'
+    autoload :Base,             'solargraph/pin/base'
+    autoload :Method,           'solargraph/pin/method'
+    autoload :Signature,        'solargraph/pin/signature'
+    autoload :MethodAlias,      'solargraph/pin/method_alias'
+    autoload :BaseVariable,     'solargraph/pin/base_variable'
+    autoload :InstanceVariable, 'solargraph/pin/instance_variable'
+    autoload :ClassVariable,    'solargraph/pin/class_variable'
+    autoload :LocalVariable,    'solargraph/pin/local_variable'
+    autoload :GlobalVariable,   'solargraph/pin/global_variable'
+    autoload :Constant,         'solargraph/pin/constant'
+    autoload :Symbol,           'solargraph/pin/symbol'
+    autoload :Closure,          'solargraph/pin/closure'
+    autoload :Namespace,        'solargraph/pin/namespace'
+    autoload :Keyword,          'solargraph/pin/keyword'
+    autoload :Parameter,        'solargraph/pin/parameter'
+    autoload :Reference,        'solargraph/pin/reference'
+    autoload :Documenting,      'solargraph/pin/documenting'
+    autoload :Block,            'solargraph/pin/block'
+    autoload :Localized,        'solargraph/pin/localized'
+    autoload :ProxyType,        'solargraph/pin/proxy_type'
+    autoload :DuckMethod,       'solargraph/pin/duck_method'
+    autoload :Singleton,        'solargraph/pin/singleton'
+    autoload :KeywordParam,     'solargraph/pin/keyword_param'
+    autoload :Search,           'solargraph/pin/search'
+
+    ROOT_PIN = Pin::Namespace.new(type: :class, name: '', closure: nil)
+  end
+end

data/lib/solargraph/position.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Solargraph
+  # The zero-based line and column numbers of a position in a string.
+  #
+  class Position
+    # @return [Integer]
+    attr_reader :line
+
+    # @return [Integer]
+    attr_reader :character
+
+    alias column character
+
+    # @param line [Integer]
+    # @param character [Integer]
+    def initialize line, character
+      @line = line
+      @character = character
+    end
+
+    # Get a hash of the position. This representation is suitable for use in
+    # the language server protocol.
+    #
+    # @return [Hash]
+    def to_hash
+      {
+        line: line,
+        character: character
+      }
+    end
+
+    def inspect
+      "#<#{self.class} #{line}, #{character}>"
+    end
+
+    # Get a numeric offset for the specified text and position.
+    #
+    # @param text [String]
+    # @param position [Position]
+    # @return [Integer]
+    def self.to_offset text, position
+      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
+    # by its line and character.
+    #
+    # @param text [String]
+    # @param line [Integer]
+    # @param character [Integer]
+    # @return [Integer]
+    def self.line_char_to_offset text, line, character
+      to_offset(text, Position.new(line, character))
+    end
+
+    # Get a position for the specified text and offset.
+    #
+    # @param text [String]
+    # @param offset [Integer]
+    # @return [Position]
+    def self.from_offset text, offset
+      cursor = 0
+      line = 0
+      character = nil
+      text.lines.each do |l|
+        line_length = l.length
+        char_length = l.chomp.length
+        if cursor + char_length >= offset
+          character = offset - cursor
+          break
+        end
+        cursor += line_length
+        line += 1
+      end
+      character = 0 if character.nil? and (cursor - offset).between?(0, 1)
+      raise InvalidOffsetError if character.nil?
+      Position.new(line, character)
+    end
+
+    # A helper method for generating positions from arrays of integers. The
+    # original parameter is returned if it is already a position.
+    #
+    # @raise [ArgumentError] if the object cannot be converted to a position.
+    #
+    # @param object [Position, Array(Integer, Integer)]
+    # @return [Position]
+    def self.normalize object
+      return object if object.is_a?(Position)
+      return Position.new(object[0], object[1]) if object.is_a?(Array)
+      raise ArgumentError, "Unable to convert #{object.class} to Position"
+    end
+
+    def == other
+      return false unless other.is_a?(Position)
+      line == other.line and character == other.character
+    end
+  end
+end