jimeh-solargraph 0.40.4.0

data/lib/solargraph/source/encoding_fixes.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    module EncodingFixes
+      module_function
+
+      # Convert strings to normalized UTF-8.
+      #
+      # @param string [String]
+      # @return [String]
+      def normalize string
+        begin
+          string.dup.force_encoding('UTF-8')
+        rescue ::Encoding::CompatibilityError, ::Encoding::UndefinedConversionError, ::Encoding::InvalidByteSequenceError => e
+          # @todo Improve error handling
+          Solargraph::Logging.logger.warn "Normalize error: #{e.message}"
+          string
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/source_chainer.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    # Information about a location in a source, including the location's word
+    # and signature, literal values at the base of signatures, and whether the
+    # location is inside a string or comment. ApiMaps use Fragments to provide
+    # results for completion and definition queries.
+    #
+    class SourceChainer
+      # include Source::NodeMethods
+
+      private_class_method :new
+
+      class << self
+        # @param source [Source]
+        # @param position [Position]
+        # @return [Source::Chain]
+        def chain source, position
+          new(source, position).chain
+        end
+      end
+
+      # @param source [Source]
+      # @param position [Position]
+      def initialize source, position
+        @source = source
+        @position = position
+        @calculated_literal = false
+      end
+
+      # @return [Source::Chain]
+      def chain
+        # Special handling for files that end with an integer and a period
+        return Chain.new([Chain::Literal.new('Integer'), Chain::UNDEFINED_CALL]) if phrase =~ /^[0-9]+\.$/
+        return Chain.new([Chain::Literal.new('Symbol')]) if phrase.start_with?(':') && !phrase.start_with?('::')
+        begin
+          return Chain.new([]) if phrase.end_with?('..')
+          node = nil
+          parent = nil
+          if !source.repaired? && source.parsed? && source.synchronized?
+            tree = source.tree_at(position.line, position.column)
+            # node, parent = source.tree_at(position.line, position.column)[0..2]
+            tree.shift while tree.length > 1 && tree.first.type == :SCOPE
+            node, parent = tree[0..2]
+          elsif source.parsed? && source.repaired? && end_of_phrase == '.'
+            node, parent = source.tree_at(fixed_position.line, fixed_position.column)[0..2]
+            node = Parser.parse(fixed_phrase) if node.nil?
+          else
+            node, parent = source.tree_at(fixed_position.line, fixed_position.column)[0..2] unless source.error_ranges.any?{|r| r.nil? || r.include?(fixed_position)}
+            # Exception for positions that chain literal nodes in unsynchronized sources
+            node = nil unless source.synchronized? || !Parser.infer_literal_node_type(node).nil?
+            node = Parser.parse(fixed_phrase) if node.nil?
+          end
+        rescue Parser::SyntaxError
+          return Chain.new([Chain::UNDEFINED_CALL])
+        end
+        return Chain.new([Chain::UNDEFINED_CALL]) if node.nil? || (node.type == :sym && !phrase.start_with?(':'))
+        # chain = NodeChainer.chain(node, source.filename, parent && parent.type == :block)
+        chain = Parser.chain(node, source.filename, parent && [:ITER, :block].include?(parent.type))
+        if source.repaired? || !source.parsed? || !source.synchronized?
+          if end_of_phrase.strip == '.'
+            chain.links.push Chain::UNDEFINED_CALL
+          elsif end_of_phrase.strip == '::'
+            chain.links.push Chain::UNDEFINED_CONSTANT
+          end
+        elsif chain.links.last.is_a?(Source::Chain::Constant) && end_of_phrase.strip == '::' && !source.code[Position.to_offset(source.code, position)].match?(/[a-z]/i)
+          chain.links.push Source::Chain::UNDEFINED_CONSTANT
+        end
+        chain
+      end
+
+      private
+
+      # @return [Position]
+      attr_reader :position
+
+      # @return [Solargraph::Source]
+      attr_reader :source
+
+      # @return [String]
+      def phrase
+        @phrase ||= source.code[signature_data..offset-1]
+      end
+
+      # @return [String]
+      def fixed_phrase
+        @fixed_phrase ||= phrase[0..-(end_of_phrase.length+1)]
+      end
+
+      # @return [Position]
+      def fixed_position
+        @fixed_position ||= Position.from_offset(source.code, offset - end_of_phrase.length)
+      end
+
+      # @return [String]
+      def end_of_phrase
+        @end_of_phrase ||= begin
+          match = phrase.match(/[\s]*(\.{1}|::)[\s]*$/)
+          if match
+            match[0]
+          else
+            ''
+          end
+        end
+      end
+
+      # True if the current offset is inside a string.
+      #
+      # @return [Boolean]
+      def string?
+        # @string ||= (node.type == :str or node.type == :dstr)
+        @string ||= @source.string_at?(position)
+      end
+
+      # @return [Integer]
+      def offset
+        @offset ||= get_offset(position.line, position.column)
+      end
+
+      # @param line [Integer]
+      # @param column [Integer]
+      # @return [Integer]
+      def get_offset line, column
+        Position.line_char_to_offset(@source.code, line, column)
+      end
+
+      def signature_data
+        @signature_data ||= get_signature_data_at(offset)
+      end
+
+      def get_signature_data_at index
+        brackets = 0
+        squares = 0
+        parens = 0
+        index -=1
+        in_whitespace = false
+        while index >= 0
+          pos = Position.from_offset(@source.code, index)
+          break if index > 0 and @source.comment_at?(pos)
+          break if brackets > 0 or parens > 0 or squares > 0
+          char = @source.code[index, 1]
+          break if char.nil? # @todo Is this the right way to handle this?
+          if brackets.zero? and parens.zero? and squares.zero? and [' ', "\r", "\n", "\t"].include?(char)
+            in_whitespace = true
+          else
+            if brackets.zero? and parens.zero? and squares.zero? and in_whitespace
+              unless char == '.' or @source.code[index+1..-1].strip.start_with?('.')
+                old = @source.code[index+1..-1]
+                nxt = @source.code[index+1..-1].lstrip
+                index += (@source.code[index+1..-1].length - @source.code[index+1..-1].lstrip.length)
+                break
+              end
+            end
+            if char == ')'
+              parens -=1
+            elsif char == ']'
+              squares -=1
+            elsif char == '}'
+              brackets -= 1
+            elsif char == '('
+              parens += 1
+            elsif char == '{'
+              brackets += 1
+            elsif char == '['
+              squares += 1
+            end
+            if brackets.zero? and parens.zero? and squares.zero?
+              break if ['"', "'", ',', ';', '%'].include?(char)
+              break if ['!', '?'].include?(char) && index < offset - 1
+              break if char == '$'
+              if char == '@'
+                index -= 1
+                if @source.code[index, 1] == '@'
+                  index -= 1
+                end
+                break
+              end
+            elsif parens == 1 || brackets == 1 || squares == 1
+              break
+            end
+            in_whitespace = false
+          end
+          index -= 1
+        end
+        index + 1
+      end
+    end
+  end
+end

data/lib/solargraph/source/updater.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    # Updaters contain changes to be applied to a source. The source applies
+    # the update via the Source#synchronize method.
+    #
+    class Updater
+      # @return [String]
+      attr_reader :filename
+
+      # @return [Integer]
+      attr_reader :version
+
+      # @return [Array<Change>]
+      attr_reader :changes
+
+      # @param filename [String] The file to update.
+      # @param version [Integer] A version number associated with this update.
+      # @param changes [Array<Solargraph::Source::Change>] The changes.
+      def initialize filename, version, changes
+        @filename = filename
+        @version = version
+        @changes = changes
+        @input = nil
+        @did_nullify = nil
+        @output = nil
+      end
+
+      # @param text [String]
+      # @param nullable [Boolean]
+      # @return [String]
+      def write text, nullable = false
+        can_nullify = (nullable and changes.length == 1)
+        return @output if @input == text and can_nullify == @did_nullify
+        @input = text
+        @output = text
+        @did_nullify = can_nullify
+        changes.each do |ch|
+          @output = ch.write(@output, can_nullify)
+        end
+        @output
+      end
+
+      # @return [String]
+      def repair text
+        changes.each do |ch|
+          text = ch.repair(text)
+        end
+        text
+      end
+    end
+  end
+end

data/lib/solargraph/source_map.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require 'jaro_winkler'
+require 'yard'
+require 'yard-solargraph'
+require 'set'
+
+module Solargraph
+  # An index of pins and other ApiMap-related data for a Source.
+  #
+  class SourceMap
+    autoload :Mapper,        'solargraph/source_map/mapper'
+    autoload :Clip,          'solargraph/source_map/clip'
+    autoload :Completion,    'solargraph/source_map/completion'
+
+    # @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
+      environ.merge Convention.for_local(self) unless filename.nil?
+      @pin_class_hash = pins.to_set.classify(&:class).transform_values(&:to_a)
+      @pin_select_cache = {}
+    end
+
+    def pins_by_class klass
+      @pin_select_cache[klass] ||= @pin_class_hash.select { |key, _| key <= klass }.values.flatten
+    end
+
+    def rebindable_method_names
+      @rebindable_method_names ||= pins_by_class(Pin::Method)
+        .select { |pin| pin.comments && pin.comments.include?('@yieldself') }
+        .map(&:name)
+        .to_set
+    end
+
+    # @return [String]
+    def filename
+      source.filename
+    end
+
+    # @return [String]
+    def code
+      source.code
+    end
+
+    # @return [Array<Pin::Reference::Require>]
+    def requires
+      pins_by_class(Pin::Reference::Require)
+    end
+
+    # @return [Environ]
+    def environ
+      @environ ||= Environ.new
+    end
+
+    # @return [Array<Pin::Base>]
+    def document_symbols
+      @document_symbols ||= pins.select { |pin|
+        pin.path && !pin.path.empty?
+      }
+    end
+
+    # @param query [String]
+    # @return [Array<Pin::Base>]
+    def query_symbols query
+      return document_symbols if query && query.empty?
+      document_symbols.select{ |pin| fuzzy_string_match(pin.path, query) || fuzzy_string_match(pin.name, query) }
+    end
+
+    # @param position [Position]
+    # @return [Source::Cursor]
+    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 + locals).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
+
+    # @param location [Location]
+    # @return [Array<Pin::LocalVariable>]
+    def locals_at(location)
+      return [] if location.filename != filename
+      locals.select { |pin| pin.visible_at?(location) }
+    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 klasses [Array<Class>]
+    # @return [Pin::Base]
+    def _locate_pin line, character, *klasses
+      position = Position.new(line, character)
+      found = nil
+      pins.each do |pin|
+        # @todo Attribute pins should not be treated like closures, but
+        #   there's probably a better way to handle it
+        next if pin.is_a?(Pin::Method) && pin.attribute?
+        found = pin if (klasses.empty? || klasses.any? { |kls| pin.is_a?(kls) } ) && pin.location.range.contain?(position)
+        break if pin.location.range.start.line > line
+      end
+      # 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