solargraph 0.32.1 → 0.32.2

data/lib/solargraph/source_map.rb

@@ -1,169 +1,169 @@
-require 'jaro_winkler'
-
-module Solargraph
-  # An index of pins and other ApiMap-related data for a Source.
-  #
-  class SourceMap
-    autoload :NodeProcessor, 'solargraph/source_map/node_processor'
-    autoload :Mapper,        'solargraph/source_map/mapper'
-    autoload :Clip,          'solargraph/source_map/clip'
-    autoload :Completion,    'solargraph/source_map/completion'
-    autoload :Region,        'solargraph/source_map/region'
-
-    # @return [Source]
-    attr_reader :source
-
-    # @return [Array<Pin::Base>]
-    attr_reader :pins
-
-    # @return [Array<Pin::Base>]
-    attr_reader :locals
-
-    # @param source [Source]
-    # @param pins [Array<Pin::Base>]
-    # @param locals [Array<Pin::Base>]
-    def initialize source, pins, locals
-      # HACK: Keep the library from changing this
-      @source = source.dup
-      @pins = pins
-      @locals = locals
-    end
-
-    # @return [String]
-    def filename
-      source.filename
-    end
-
-    # @return [String]
-    def code
-      source.code
-    end
-
-    # @return [Array<Pin::Reference::Require>]
-    def requires
-      @requires ||= pins.select{|p| p.kind == Pin::REQUIRE_REFERENCE}
-    end
-
-    # @param position [Position, Array(Integer, Integer)]
-    # @return [Boolean]
-    def string_at? position
-      position = Position.normalize(position)
-      @source.string_at?(position)
-    end
-
-    # @param position [Position, Array(Integer, Integer)]
-    # @return [Boolean]
-    def comment_at? position
-      position = Position.normalize(position)
-      @source.comment_at?(position)
-    end
-
-    # @return [Array<Pin::Base>]
-    def document_symbols
-      @document_symbols ||= pins.select { |pin|
-        [Pin::ATTRIBUTE, Pin::CONSTANT, Pin::METHOD, Pin::NAMESPACE].include?(pin.kind) and !pin.path.empty?
-      }
-    end
-
-    # @param query [String]
-    # @return [Array<Pin::Base>]
-    def query_symbols query
-      document_symbols.select{ |pin| fuzzy_string_match(pin.path, query) || fuzzy_string_match(pin.name, query) }
-    end
-
-    # @param position [Position]
-    # @return [Solargraph::SourceMap::Fragment]
-    def cursor_at position
-      Source::Cursor.new(source, position)
-    end
-
-    # @param path [String]
-    # @return [Pin::Base]
-    def first_pin path
-      pins.select { |p| p.path == path }.first
-    end
-
-    # @param location [Solargraph::Location]
-    # @return [Array<Solargraph::Pin::Base>]
-    def locate_pins location
-      # return nil unless location.start_with?("#{filename}:")
-      pins.select { |pin| pin.location == location }
-    end
-
-    def locate_named_path_pin line, character
-      _locate_pin line, character, Pin::NAMESPACE, Pin::METHOD
-    end
-
-    def locate_block_pin line, character
-      _locate_pin line, character, Pin::NAMESPACE, Pin::METHOD, Pin::BLOCK
-    end
-
-    # @param other_map [SourceMap]
-    # @return [Boolean]
-    def try_merge! other_map
-      return false if pins.length != other_map.pins.length || locals.length != other_map.locals.length || requires.map(&:name).uniq.sort != other_map.requires.map(&:name).uniq.sort
-      pins.each_index do |i|
-        return false unless pins[i].try_merge!(other_map.pins[i])
-      end
-      locals.each_index do |i|
-        return false unless locals[i].try_merge!(other_map.locals[i])
-      end
-      @source = other_map.source
-      true
-    end
-
-    # @param name [String]
-    # @return [Array<Location>]
-    def references name
-      source.references name
-    end
-
-    class << self
-      # @param filename [String]
-      # @return [SourceMap]
-      def load filename
-        source = Solargraph::Source.load(filename)
-        SourceMap.map(source)
-      end
-
-      # @param code [String]
-      # @param filename [String, nil]
-      # @return [SourceMap]
-      def load_string code, filename = nil
-        source = Solargraph::Source.load_string(code, filename)
-        SourceMap.map(source)
-      end
-
-      # @param source [Source]
-      # @return [SourceMap]
-      def map source
-        result = SourceMap::Mapper.map(source)
-        new(source, *result)
-      end
-    end
-
-    private
-
-    # @param line [Integer]
-    # @param character [Integer]
-    # @param *kinds [Array<Symbol>]
-    # @return [Pin::Base]
-    def _locate_pin line, character, *kinds
-      position = Position.new(line, character)
-      found = nil
-      pins.each do |pin|
-        found = pin if (kinds.empty? || kinds.include?(pin.kind)) && pin.location.range.contain?(position)
-        break if pin.location.range.start.line > line
-      end
-      # @todo Assuming the root pin is always valid
-      found || pins.first
-    end
-
-    # @param str1 [String]
-    # @param str2 [String]
-    # @return [Boolean]
-    def fuzzy_string_match str1, str2
-      JaroWinkler.distance(str1, str2) > 0.6
-    end
-  end
-end
+require 'jaro_winkler'
+
+module Solargraph
+  # An index of pins and other ApiMap-related data for a Source.
+  #
+  class SourceMap
+    autoload :NodeProcessor, 'solargraph/source_map/node_processor'
+    autoload :Mapper,        'solargraph/source_map/mapper'
+    autoload :Clip,          'solargraph/source_map/clip'
+    autoload :Completion,    'solargraph/source_map/completion'
+    autoload :Region,        'solargraph/source_map/region'
+
+    # @return [Source]
+    attr_reader :source
+
+    # @return [Array<Pin::Base>]
+    attr_reader :pins
+
+    # @return [Array<Pin::Base>]
+    attr_reader :locals
+
+    # @param source [Source]
+    # @param pins [Array<Pin::Base>]
+    # @param locals [Array<Pin::Base>]
+    def initialize source, pins, locals
+      # HACK: Keep the library from changing this
+      @source = source.dup
+      @pins = pins
+      @locals = locals
+    end
+
+    # @return [String]
+    def filename
+      source.filename
+    end
+
+    # @return [String]
+    def code
+      source.code
+    end
+
+    # @return [Array<Pin::Reference::Require>]
+    def requires
+      @requires ||= pins.select{|p| p.kind == Pin::REQUIRE_REFERENCE}
+    end
+
+    # @param position [Position, Array(Integer, Integer)]
+    # @return [Boolean]
+    def string_at? position
+      position = Position.normalize(position)
+      @source.string_at?(position)
+    end
+
+    # @param position [Position, Array(Integer, Integer)]
+    # @return [Boolean]
+    def comment_at? position
+      position = Position.normalize(position)
+      @source.comment_at?(position)
+    end
+
+    # @return [Array<Pin::Base>]
+    def document_symbols
+      @document_symbols ||= pins.select { |pin|
+        [Pin::ATTRIBUTE, Pin::CONSTANT, Pin::METHOD, Pin::NAMESPACE].include?(pin.kind) and !pin.path.empty?
+      }
+    end
+
+    # @param query [String]
+    # @return [Array<Pin::Base>]
+    def query_symbols query
+      document_symbols.select{ |pin| fuzzy_string_match(pin.path, query) || fuzzy_string_match(pin.name, query) }
+    end
+
+    # @param position [Position]
+    # @return [Solargraph::SourceMap::Fragment]
+    def cursor_at position
+      Source::Cursor.new(source, position)
+    end
+
+    # @param path [String]
+    # @return [Pin::Base]
+    def first_pin path
+      pins.select { |p| p.path == path }.first
+    end
+
+    # @param location [Solargraph::Location]
+    # @return [Array<Solargraph::Pin::Base>]
+    def locate_pins location
+      # return nil unless location.start_with?("#{filename}:")
+      pins.select { |pin| pin.location == location }
+    end
+
+    def locate_named_path_pin line, character
+      _locate_pin line, character, Pin::NAMESPACE, Pin::METHOD
+    end
+
+    def locate_block_pin line, character
+      _locate_pin line, character, Pin::NAMESPACE, Pin::METHOD, Pin::BLOCK
+    end
+
+    # @param other_map [SourceMap]
+    # @return [Boolean]
+    def try_merge! other_map
+      return false if pins.length != other_map.pins.length || locals.length != other_map.locals.length || requires.map(&:name).uniq.sort != other_map.requires.map(&:name).uniq.sort
+      pins.each_index do |i|
+        return false unless pins[i].try_merge!(other_map.pins[i])
+      end
+      locals.each_index do |i|
+        return false unless locals[i].try_merge!(other_map.locals[i])
+      end
+      @source = other_map.source
+      true
+    end
+
+    # @param name [String]
+    # @return [Array<Location>]
+    def references name
+      source.references name
+    end
+
+    class << self
+      # @param filename [String]
+      # @return [SourceMap]
+      def load filename
+        source = Solargraph::Source.load(filename)
+        SourceMap.map(source)
+      end
+
+      # @param code [String]
+      # @param filename [String, nil]
+      # @return [SourceMap]
+      def load_string code, filename = nil
+        source = Solargraph::Source.load_string(code, filename)
+        SourceMap.map(source)
+      end
+
+      # @param source [Source]
+      # @return [SourceMap]
+      def map source
+        result = SourceMap::Mapper.map(source)
+        new(source, *result)
+      end
+    end
+
+    private
+
+    # @param line [Integer]
+    # @param character [Integer]
+    # @param *kinds [Array<Symbol>]
+    # @return [Pin::Base]
+    def _locate_pin line, character, *kinds
+      position = Position.new(line, character)
+      found = nil
+      pins.each do |pin|
+        found = pin if (kinds.empty? || kinds.include?(pin.kind)) && pin.location.range.contain?(position)
+        break if pin.location.range.start.line > line
+      end
+      # @todo Assuming the root pin is always valid
+      found || pins.first
+    end
+
+    # @param str1 [String]
+    # @param str2 [String]
+    # @return [Boolean]
+    def fuzzy_string_match str1, str2
+      JaroWinkler.distance(str1, str2) > 0.6
+    end
+  end
+end

data/lib/solargraph/source_map/clip.rb

@@ -1,145 +1,145 @@
-module Solargraph
-  class SourceMap
-    # A static analysis tool for obtaining definitions, completions,
-    # signatures, and type inferences from a cursor.
-    #
-    class Clip
-      # @param api_map [ApiMap]
-      # @param cursor [Source::Cursor]
-      def initialize api_map, cursor
-        @api_map = api_map
-        @cursor = cursor
-      end
-
-      # @return [Array<Pin::Base>]
-      def define
-        return [] if cursor.comment? || cursor.chain.literal?
-        result = cursor.chain.define(api_map, context_pin, locals)
-        result.concat((source_map.pins + source_map.locals).select{ |p| p.name == cursor.word && p.location.range.contain?(cursor.position) }) if result.empty?
-        result
-      end
-
-      # @return [Completion]
-      def complete
-        return package_completions(api_map.get_symbols) if cursor.chain.literal? && cursor.chain.links.last.word == '<Symbol>'
-        return Completion.new([], cursor.range) if cursor.chain.literal? || cursor.comment?
-        result = []
-        if cursor.chain.constant? || cursor.start_of_constant?
-          if cursor.chain.undefined?
-            type = cursor.chain.base.infer(api_map, context_pin, locals)
-          else
-            full = cursor.chain.links.first.word
-            if full.include?('::') && cursor.chain.links.length == 1
-              type = ComplexType.try_parse(full.split('::')[0..-2].join('::'))
-            elsif cursor.chain.links.length > 1
-              type = ComplexType.try_parse(full)
-            else
-              type = ComplexType::UNDEFINED
-            end
-          end
-          result.concat api_map.get_constants(type.undefined? ? '' : type.namespace, cursor.start_of_constant? ? '' : context_pin.context.namespace)
-        else
-          type = cursor.chain.base.infer(api_map, context_pin, locals)
-          result.concat api_map.get_complex_type_methods(type, context_pin.context.namespace, cursor.chain.links.length == 1)
-          if cursor.chain.links.length == 1
-            if cursor.word.start_with?('@@')
-              return package_completions(api_map.get_class_variable_pins(context_pin.context.namespace))
-            elsif cursor.word.start_with?('@')
-              return package_completions(api_map.get_instance_variable_pins(context_pin.context.namespace, context_pin.context.scope))
-            elsif cursor.word.start_with?('$')
-              return package_completions(api_map.get_global_variable_pins)
-            end
-            result.concat locals
-            result.concat api_map.get_constants('', context_pin.context.namespace)
-            result.concat api_map.get_methods(context_pin.context.namespace, scope: context_pin.context.scope, visibility: [:public, :private, :protected])
-            result.concat api_map.get_methods('Kernel')
-            result.concat ApiMap.keywords
-            result.concat yielded_self_pins
-          end
-        end
-        package_completions(result)
-      end
-
-      # @return [Array<Pin::Base>]
-      def signify
-        return [] unless cursor.argument?
-        clip = Clip.new(api_map, cursor.recipient)
-        clip.define.select{|pin| pin.kind == Pin::METHOD}
-      end
-
-      # @return [ComplexType]
-      def infer
-        cursor.chain.infer(api_map, context_pin, locals)
-      end
-
-      # Get an array of all the locals that are visible from the cursors's
-      # position. Locals can be local variables, method parameters, or block
-      # parameters. The array starts with the nearest local pin.
-      #
-      # @return [Array<Solargraph::Pin::Base>]
-      def locals
-        loc_pos = context_pin.location.range.contain?(cursor.position) ? cursor.position : context_pin.location.range.ending
-        adj_pos = Position.new(loc_pos.line, (loc_pos.column.zero? ? 0 : loc_pos.column - 1))
-        @locals ||= source_map.locals.select { |pin|
-          pin.visible_from?(block, adj_pos)
-        }.reverse
-      end
-
-      private
-
-      # @return [ApiMap]
-      attr_reader :api_map
-
-      # @return [Source::Cursor]
-      attr_reader :cursor
-
-      # @return [SourceMap]
-      def source_map
-        @source_map ||= api_map.source_map(cursor.filename)
-      end
-
-      # @return [Solargraph::Pin::Base]
-      def block
-        @block ||= source_map.locate_block_pin(cursor.node_position.line, cursor.node_position.character)
-      end
-
-      # The context at the current position.
-      #
-      # @return [Pin::Base]
-      def context_pin
-        @context_pin ||= source_map.locate_named_path_pin(cursor.node_position.line, cursor.node_position.character)
-      end
-
-      # @return [Array<Pin::Base>]
-      def yielded_self_pins
-        return [] unless block.is_a?(Pin::Block) && block.receiver
-        chain = Solargraph::Source::NodeChainer.chain(block.receiver, source_map.source.filename)
-        receiver_pin = chain.define(api_map, context_pin, locals).first
-        return [] if receiver_pin.nil?
-        result = []
-        ys = receiver_pin.docstring.tag(:yieldself)
-        unless ys.nil? || ys.types.empty?
-          ysct = ComplexType.try_parse(*ys.types).qualify(api_map, receiver_pin.context.namespace)
-          result.concat api_map.get_complex_type_methods(ysct, ysct.namespace, true)
-        end
-        ys = receiver_pin.docstring.tag(:yieldpublic)
-        unless ys.nil? || ys.types.empty?
-          ysct = ComplexType.try_parse(*ys.types).qualify(api_map, receiver_pin.context.namespace)
-          result.concat api_map.get_complex_type_methods(ysct, '', false)
-        end
-        result
-      end
-
-      # @param result [Array<Pin::Base>]
-      # @return [Completion]
-      def package_completions result
-        frag_start = cursor.start_of_word.to_s.downcase
-        filtered = result.uniq(&:name).select { |s|
-          s.name.downcase.start_with?(frag_start) &&
-            (s.kind != Pin::METHOD || s.name.match(/^[a-z0-9_]+(\!|\?|=)?$/i))
-        }
-        Completion.new(filtered, cursor.range)
-      end
-    end
-  end
-end
+module Solargraph
+  class SourceMap
+    # A static analysis tool for obtaining definitions, completions,
+    # signatures, and type inferences from a cursor.
+    #
+    class Clip
+      # @param api_map [ApiMap]
+      # @param cursor [Source::Cursor]
+      def initialize api_map, cursor
+        @api_map = api_map
+        @cursor = cursor
+      end
+
+      # @return [Array<Pin::Base>]
+      def define
+        return [] if cursor.comment? || cursor.chain.literal?
+        result = cursor.chain.define(api_map, context_pin, locals)
+        result.concat((source_map.pins + source_map.locals).select{ |p| p.name == cursor.word && p.location.range.contain?(cursor.position) }) if result.empty?
+        result
+      end
+
+      # @return [Completion]
+      def complete
+        return package_completions(api_map.get_symbols) if cursor.chain.literal? && cursor.chain.links.last.word == '<Symbol>'
+        return Completion.new([], cursor.range) if cursor.chain.literal? || cursor.comment?
+        result = []
+        if cursor.chain.constant? || cursor.start_of_constant?
+          if cursor.chain.undefined?
+            type = cursor.chain.base.infer(api_map, context_pin, locals)
+          else
+            full = cursor.chain.links.first.word
+            if full.include?('::') && cursor.chain.links.length == 1
+              type = ComplexType.try_parse(full.split('::')[0..-2].join('::'))
+            elsif cursor.chain.links.length > 1
+              type = ComplexType.try_parse(full)
+            else
+              type = ComplexType::UNDEFINED
+            end
+          end
+          result.concat api_map.get_constants(type.undefined? ? '' : type.namespace, cursor.start_of_constant? ? '' : context_pin.context.namespace)
+        else
+          type = cursor.chain.base.infer(api_map, context_pin, locals)
+          result.concat api_map.get_complex_type_methods(type, context_pin.context.namespace, cursor.chain.links.length == 1)
+          if cursor.chain.links.length == 1
+            if cursor.word.start_with?('@@')
+              return package_completions(api_map.get_class_variable_pins(context_pin.context.namespace))
+            elsif cursor.word.start_with?('@')
+              return package_completions(api_map.get_instance_variable_pins(context_pin.context.namespace, context_pin.context.scope))
+            elsif cursor.word.start_with?('$')
+              return package_completions(api_map.get_global_variable_pins)
+            end
+            result.concat locals
+            result.concat api_map.get_constants('', context_pin.context.namespace)
+            result.concat api_map.get_methods(context_pin.context.namespace, scope: context_pin.context.scope, visibility: [:public, :private, :protected])
+            result.concat api_map.get_methods('Kernel')
+            result.concat ApiMap.keywords
+            result.concat yielded_self_pins
+          end
+        end
+        package_completions(result)
+      end
+
+      # @return [Array<Pin::Base>]
+      def signify
+        return [] unless cursor.argument?
+        clip = Clip.new(api_map, cursor.recipient)
+        clip.define.select{|pin| pin.kind == Pin::METHOD}
+      end
+
+      # @return [ComplexType]
+      def infer
+        cursor.chain.infer(api_map, context_pin, locals)
+      end
+
+      # Get an array of all the locals that are visible from the cursors's
+      # position. Locals can be local variables, method parameters, or block
+      # parameters. The array starts with the nearest local pin.
+      #
+      # @return [Array<Solargraph::Pin::Base>]
+      def locals
+        loc_pos = context_pin.location.range.contain?(cursor.position) ? cursor.position : context_pin.location.range.ending
+        adj_pos = Position.new(loc_pos.line, (loc_pos.column.zero? ? 0 : loc_pos.column - 1))
+        @locals ||= source_map.locals.select { |pin|
+          pin.visible_from?(block, adj_pos)
+        }.reverse
+      end
+
+      private
+
+      # @return [ApiMap]
+      attr_reader :api_map
+
+      # @return [Source::Cursor]
+      attr_reader :cursor
+
+      # @return [SourceMap]
+      def source_map
+        @source_map ||= api_map.source_map(cursor.filename)
+      end
+
+      # @return [Solargraph::Pin::Base]
+      def block
+        @block ||= source_map.locate_block_pin(cursor.node_position.line, cursor.node_position.character)
+      end
+
+      # The context at the current position.
+      #
+      # @return [Pin::Base]
+      def context_pin
+        @context_pin ||= source_map.locate_named_path_pin(cursor.node_position.line, cursor.node_position.character)
+      end
+
+      # @return [Array<Pin::Base>]
+      def yielded_self_pins
+        return [] unless block.is_a?(Pin::Block) && block.receiver
+        chain = Solargraph::Source::NodeChainer.chain(block.receiver, source_map.source.filename)
+        receiver_pin = chain.define(api_map, context_pin, locals).first
+        return [] if receiver_pin.nil?
+        result = []
+        ys = receiver_pin.docstring.tag(:yieldself)
+        unless ys.nil? || ys.types.empty?
+          ysct = ComplexType.try_parse(*ys.types).qualify(api_map, receiver_pin.context.namespace)
+          result.concat api_map.get_complex_type_methods(ysct, ysct.namespace, true)
+        end
+        ys = receiver_pin.docstring.tag(:yieldpublic)
+        unless ys.nil? || ys.types.empty?
+          ysct = ComplexType.try_parse(*ys.types).qualify(api_map, receiver_pin.context.namespace)
+          result.concat api_map.get_complex_type_methods(ysct, '', false)
+        end
+        result
+      end
+
+      # @param result [Array<Pin::Base>]
+      # @return [Completion]
+      def package_completions result
+        frag_start = cursor.start_of_word.to_s.downcase
+        filtered = result.uniq(&:name).select { |s|
+          s.name.downcase.start_with?(frag_start) &&
+            (s.kind != Pin::METHOD || s.name.match(/^[a-z0-9_]+(\!|\?|=)?$/i))
+        }
+        Completion.new(filtered, cursor.range)
+      end
+    end
+  end
+end