solargraph 0.26.1 → 0.27.0

data/lib/solargraph/source/encoding_fixes.rb

@@ -9,7 +9,7 @@ module Solargraph
       # @return [String]
       def normalize string
         begin
-          string.force_encoding('UTF-8')
+          string.clone.force_encoding('UTF-8')
         rescue ::Encoding::CompatibilityError, ::Encoding::UndefinedConversionError, ::Encoding::InvalidByteSequenceError => e
           # @todo Improve error handling
           STDERR.puts "Normalize error: #{e.message}"

data/lib/solargraph/source/node_chainer.rb

@@ -1,11 +1,11 @@
 module Solargraph
   class Source
     class NodeChainer
-      include NodeMethods
+      include Source::NodeMethods
 
-      def initialize filename, node
-        @filename = filename
+      def initialize node, filename = nil
         @node = node
+        @filename = filename
         # @source = source
         # @line = line
         # @column = column
@@ -14,23 +14,23 @@ module Solargraph
       # @return [Source::Chain]
       def chain
         links = generate_links(@node)
-        Chain.new(@filename, links)
+        Chain.new(links)
       end
 
       class << self
-        # @param source [Source]
-        # @param line [Integer]
-        # @param column [Integer]
-        # @return [Source::Chain]
-        def chain filename, node
-          NodeChainer.new(filename, node).chain
+        # @param node [Parser::AST::Node]
+        # @param filename [String]
+        # @return [Chain]
+        def chain node, filename = nil
+          NodeChainer.new(node, filename).chain
         end
 
         # @param code [String]
+        # @param filename [String, nil]
         # @return [Chain]
-        def load_string(filename, code)
-          node = Source.parse_node(code.sub(/\.$/, ''), filename)
-          chain = Chain.new(filename, node)
+        def load_string(code)
+          node = Source.parse(code.sub(/\.$/, ''))
+          chain = NodeChainer.new(node).chain
           chain.links.push(Chain::Link.new) if code.end_with?('.')
           chain
         end
@@ -54,24 +54,29 @@ module Solargraph
             result.concat generate_links(n.children[0])
             args = []
             n.children[2..-1].each do |c|
-              # @todo Handle link parameters
-              # args.push Chain.new(source, c.loc.last_line - 1, c.loc.column)
+              args.push NodeChainer.chain(c)
             end
             result.push Chain::Call.new(n.children[1].to_s, args)
           elsif n.children[0].nil?
             args = []
             n.children[2..-1].each do |c|
-              # @todo Handle link parameters
-              # args.push Chain.new(source, c.loc.last_line - 1, c.loc.column)
+              args.push NodeChainer.chain(c)
             end
             result.push Chain::Call.new(n.children[1].to_s, args)
           else
             raise "No idea what to do with #{n}"
           end
         elsif n.type == :self
-          result.push Chain::Call.new('self')
+          result.push Chain::Head.new('self')
+        elsif n.type == :zsuper
+          result.push Chain::Head.new('super')
         elsif n.type == :const
-          result.push Chain::Constant.new(unpack_name(n))
+          # result.push Chain::Constant.new(unpack_name(n))
+          const = unpack_name(n)
+          parts = const.split('::')
+          last = parts.pop
+          result.push Chain::Constant.new(parts.join('::')) unless parts.empty?
+          result.push Chain::Constant.new(last)
         elsif [:lvar, :lvasgn].include?(n.type)
           result.push Chain::Call.new(n.children[0].to_s)
         elsif [:ivar, :ivasgn].include?(n.type)
@@ -81,8 +86,10 @@ module Solargraph
         elsif [:gvar, :gvasgn].include?(n.type)
           result.push Chain::GlobalVariable.new(n.children[0].to_s)
         elsif [:class, :module, :def, :defs].include?(n.type)
-          location = Solargraph::Source::Location.new(@filename, Source::Range.from_to(n.loc.expression.line - 1, n.loc.expression.column, n.loc.expression.last_line - 1, n.loc.expression.last_column))
-          result.push Chain::Definition.new(location)
+          # location = Solargraph::Location.new(@filename, Range.from_to(n.loc.expression.line, n.loc.expression.column, n.loc.expression.last_line, n.loc.expression.last_column))
+          # result.push Chain::Definition.new(location)
+          # @todo Undefined or what?
+          result.push Chain::UNDEFINED_CALL
         else
           lit = infer_literal_node_type(n)
           result.push (lit ? Chain::Literal.new(lit) : Chain::Link.new)

data/lib/solargraph/source/node_methods.rb

@@ -15,7 +15,7 @@ module Solargraph
           node.children.each { |n|
             if n.kind_of?(AST::Node)
               if n.type == :cbase
-                parts = pack_name(n)
+                parts = [''] + pack_name(n)
               else
                 parts += pack_name(n)
               end

data/lib/solargraph/source/source_chainer.rb

@@ -0,0 +1,217 @@
+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
+          raise "Not a source" unless source.is_a?(Source)
+          new(source, position).chain
+        end
+      end
+
+      # @param source [Source]
+      # @param position [Position]
+      def initialize source, position
+        @source = source
+        # @source.code = source.code
+        @position = position
+        # @todo Get rid of line/column
+        @line = position.line
+        @column = position.column
+        @calculated_literal = false
+      end
+
+      # @return [Source::Chain]
+      def chain
+        return Chain.new([Chain::Literal.new('Symbol')]) if phrase.start_with?(':') && !phrase.start_with?('::')
+        begin
+          if source.repaired? && source.parsed?
+            node = source.node_at(fixed_position.line, fixed_position.column)
+          elsif source.parsed?
+            node = source.node_at(position.line, position.column)
+          else
+            node = Source.parse(fixed_phrase)
+          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)
+        if source.repaired? || !source.parsed?
+          if end_of_phrase.strip == '.'
+            chain.links.push Chain::UNDEFINED_CALL
+          elsif end_of_phrase.strip == '::'
+            chain.links.push Chain::UNDEFINED_CONSTANT
+          end
+        elsif end_of_phrase.strip == '::'
+          chain.links.pop
+          chain.links.push Chain::UNDEFINED_CONSTANT
+        end
+        chain
+      end
+
+      private
+
+      attr_reader :position
+
+      # The zero-based line number of the fragment's location.
+      #
+      # @return [Integer]
+      attr_reader :line
+
+      # The zero-based column number of the fragment's location.
+      #
+      # @return [Integer]
+      attr_reader :column
+
+      # @return [Solargraph::Source]
+      attr_reader :source
+
+      def phrase
+        @phrase ||= source.code[signature_data[0]..offset-1]
+      end
+
+      def fixed_phrase
+        @fixed_phrase ||= phrase[0..-(end_of_phrase.length+1)]
+      end
+
+      def fixed_position
+        @fixed_position ||= Position.from_offset(source.code, offset - end_of_phrase.length)
+      end
+
+      def end_of_phrase
+        @end_of_phrase ||= begin
+          match = phrase.match(/[\s]*(\.{1}|::)[\s]*$/)
+          if match
+            match[0]
+          else
+            ''
+          end
+        end
+      end
+
+      # An alias for #column.
+      #
+      # @return [Integer]
+      def character
+        @column
+      end
+
+      # @return [Position]
+      def position
+        @position ||= Position.new(line, column)
+      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(line, column)
+      end
+
+      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
+        signature = ''
+        index -=1
+        in_whitespace = false
+        while index >= 0
+          pos = Position.from_offset(@source.code, index)
+          break if index > 0 and @source.comment_at?(pos)
+          unless !in_whitespace and string?
+            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
+                signature = ".[]#{signature}" if parens.zero? and brackets.zero? and squares.zero? and @source.code[index-2] != '%'
+              end
+              if brackets.zero? and parens.zero? and squares.zero?
+                break if ['"', "'", ',', ';', '%'].include?(char)
+                signature = char + signature if char.match(/[a-z0-9:\._@\$\?\!]/i) and @source.code[index - 1] != '%'
+                break if char == '$'
+                if char == '@'
+                  signature = "@#{signature}" if @source.code[index-1, 1] == '@'
+                  break
+                end
+              elsif parens == 1 || brackets == 1 || squares == 1
+                break
+              end
+              in_whitespace = false
+            end
+          end
+          index -= 1
+        end
+        # @todo Smelly exceptional case for integer literals
+        # match = signature.match(/^[0-9]+/)
+        # if match
+        #   index += match[0].length
+        #   signature = signature[match[0].length..-1].to_s
+        #   @base_literal = 'Integer'
+        # # @todo Smelly exceptional case for array literals
+        # elsif signature.start_with?('.[]')
+        #   index += 2
+        #   signature = signature[3..-1].to_s
+        #   @base_literal = 'Array'
+        # elsif signature.start_with?('.')
+        #   pos = Position.from_offset(@source.code, index)
+        #   node = @source.node_at(pos.line, pos.character)
+        #   lit = infer_literal_node_type(node)
+        #   unless lit.nil?
+        #     signature = signature[1..-1].to_s
+        #     index += 1
+        #     @base_literal = lit
+        #   end
+        # end
+        [index + 1, signature]
+      end
+    end
+  end
+end

data/lib/solargraph/source_map.rb

@@ -0,0 +1,138 @@
+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
+
+    # @return [Array<Pin::Reference>]
+    attr_reader :requires
+
+    def initialize source, pins, locals, requires, symbols
+      # HACK: Keep the library from changing this
+      @source = source.dup
+      @pins = pins
+      @locals = locals
+      @requires = requires
+      @pins.concat symbols
+    end
+
+    def filename
+      source.filename
+    end
+
+    def code
+      source.code
+    end
+
+    # @param position [Position]
+    # @return [Boolean]
+    def string_at? position
+      @source.string_at?(position)
+    end
+
+    # @param position [Position]
+    # @return [Boolean]
+    def comment_at? position
+      @source.comment_at?(position)
+    end
+
+    def document_symbols
+      @document_symbols ||= pins.select { |pin|
+        [Pin::ATTRIBUTE, Pin::CONSTANT, Pin::METHOD, Pin::NAMESPACE].include?(pin.kind) and !pin.path.empty?
+      }
+    end
+
+    def query_symbols query
+      document_symbols.select{|pin| pin.path.include?(query)}
+    end
+
+    # @param position [Position]
+    # @return [Solargraph::SourceMap::Fragment]
+    def cursor_at position
+      Source::Cursor.new(source, position)
+    end
+
+    def first_pin path
+      pins.select { |p| p.path == path }.first
+    end
+
+    # @param location [Solargraph::Location]
+    # @return [Solargraph::Pin::Base]
+    def locate_pin location
+      # return nil unless location.start_with?("#{filename}:")
+      pins.select{|pin| pin.location == location}.first
+    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]
+    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
+      # @return [SourceMap]
+      def load filename
+        source = Solargraph::Source.load(filename)
+        SourceMap.map(source)
+      end
+
+      # @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
+
+    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
+  end
+end