solargraph 0.25.1 → 0.26.0

data/lib/solargraph/pin/namespace.rb

@@ -51,8 +51,13 @@ module Solargraph
         @path ||= (namespace.empty? ? '' : "#{namespace}::") + name
       end
 
-      def return_complex_types
-        @return_complex_types ||= ComplexType.parse( (type == :class ? 'Class' : 'Module') + "<#{path}>" )
+      def return_complex_type
+        @return_complex_type ||= ComplexType.parse( (type == :class ? 'Class' : 'Module') + "<#{path}>" )
+      end
+
+      def infer api_map
+        # Assuming that namespace pins are always fully qualified
+        return_complex_type
       end
     end
   end

data/lib/solargraph/pin/proxy_type.rb

@@ -0,0 +1,39 @@
+module Solargraph
+  module Pin
+    class ProxyType < Base
+      # @param location [Solargraph::Source::Location]
+      # @param namespace [String]
+      # @param name [String]
+      # @param return_type [ComplexType]
+      def initialize location, namespace, name, return_type
+        super(location, namespace, name, '')
+        @return_complex_type = return_type
+      end
+
+      def scope
+        return_complex_type.scope
+      end
+
+      def path
+        @path ||= begin
+          result = namespace.to_s
+          result += '::' unless result.empty? or name.to_s.empty?
+          result += name.to_s
+        end
+      end
+
+      def named_context
+        path
+      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)
+      end
+    end
+  end
+end

data/lib/solargraph/pin/symbol.rb

@@ -1,19 +1,15 @@
 module Solargraph
   module Pin
-    class Symbol
-      include Conversions
-
-      attr_reader :location
-
-      attr_reader :name
-
+    class Symbol < Base
+      # @param location [Solargraph::Source::Location]
+      # @param name [String]
       def initialize location, name
         @name = name
         @location = location
       end
 
-      def filename
-        location.filename
+      def namespace
+        ''
       end
 
       def kind
@@ -21,7 +17,7 @@ module Solargraph
       end
 
       def path
-        nil
+        ''
       end
 
       def identifier
@@ -32,8 +28,20 @@ module Solargraph
         Solargraph::LanguageServer::CompletionItemKinds::KEYWORD
       end
 
-      def return_type
-        'Symbol'
+      def comments
+        ''
+      end
+
+      def return_complex_type
+        @return_complex_type ||= Solargraph::ComplexType::SYMBOL
+      end
+
+      def directives
+        []
+      end
+
+      def deprecated?
+        false
       end
     end
   end

data/lib/solargraph/pin/yard_pin/method.rb

@@ -9,8 +9,8 @@ module Solargraph
           super(location, code_object.namespace.to_s, code_object.name.to_s, comments, code_object.scope, code_object.visibility, get_parameters(code_object))
         end
 
-        def return_complex_types
-          @return_complex_types ||= Solargraph::ComplexType.parse(Solargraph::CoreFills::CUSTOM_RETURN_TYPES[path]) if Solargraph::CoreFills::CUSTOM_RETURN_TYPES.has_key?(path)
+        def return_complex_type
+          @return_complex_type ||= Solargraph::ComplexType.parse(Solargraph::CoreFills::CUSTOM_RETURN_TYPES[path]) if Solargraph::CoreFills::CUSTOM_RETURN_TYPES.has_key?(path)
           super
         end
 

data/lib/solargraph/source.rb

@@ -13,6 +13,13 @@ module Solargraph
     autoload :Change,        'solargraph/source/change'
     autoload :Mapper,        'solargraph/source/mapper'
     autoload :NodeMethods,   'solargraph/source/node_methods'
+    autoload :Chain,         'solargraph/source/chain'
+    autoload :EncodingFixes, 'solargraph/source/encoding_fixes'
+    autoload :CallChainer,   'solargraph/source/call_chainer'
+    autoload :NodeChainer,   'solargraph/source/node_chainer'
+    autoload :Completion,    'solargraph/source/completion'
+
+    include EncodingFixes
 
     # @return [String]
     attr_reader :code
@@ -60,21 +67,32 @@ module Solargraph
     # @param filename [String]
     def initialize code, filename = nil
       begin
-        @code = code
-        @fixed = code
+        @code = normalize(code)
+        @fixed = @code
         @filename = filename
         @version = 0
         @domains = []
-        begin
-          parse
-        rescue Parser::SyntaxError, EncodingError
-          hard_fix_node
-        end
+        parse
+      rescue Parser::SyntaxError, EncodingError => e
+        hard_fix_node
       rescue Exception => e
-        raise RuntimeError, "Error parsing #{filename || '(source)'}: [#{e.class}] #{e.message}"
+        STDERR.puts e.message
+        STDERR.puts e.backtrace
+        raise "Error parsing #{filename || '(source)'}: [#{e.class}] #{e.message}"
       end
     end
 
+    # @param range [Solargraph::Source::Range]
+    def at range
+      from_to range.start.line, range.start.character, range.ending.line, range.ending.character
+    end
+
+    def from_to l1, c1, l2, c2
+      b = Solargraph::Source::Position.line_char_to_offset(@code, l1, c1)
+      e = Solargraph::Source::Position.line_char_to_offset(@code, l2, c2)
+      @code[b..e-1]
+    end
+
     def macro path
       @path_macros[path]
     end
@@ -122,11 +140,6 @@ module Solargraph
       pins.select{|pin| pin.kind == Pin::CLASS_VARIABLE}
     end
 
-    # @return [Array<Solargraph::Pin::Base>]
-    def locals
-      @locals
-    end
-
     # @return [Array<Solargraph::Pin::GlobalVariable>]
     def global_variable_pins
       pins.select{|pin| pin.kind == Pin::GLOBAL_VARIABLE}
@@ -168,6 +181,11 @@ module Solargraph
       _locate_pin line, character, Pin::NAMESPACE, Pin::METHOD
     end
 
+    # Locate the namespace pin at the specified line and character.
+    #
+    # @param line [line]
+    # @param character [character]
+    # @return [Pin::Namespace]
     def locate_namespace_pin line, character
       _locate_pin line, character, Pin::NAMESPACE
     end
@@ -191,21 +209,43 @@ module Solargraph
     # @param column [Integer]
     # @return [Boolean]
     def string_at?(line, column)
-      node = node_at(line, column)
-      # @todo raise InvalidOffset or InvalidRange or something?
-      return false if node.nil?
-      node.type == :str or node.type == :dstr
+      # node = node_at(line, column)
+      # # @todo raise InvalidOffset or InvalidRange or something?
+      # return false if node.nil?
+      # node.type == :str or node.type == :dstr
+      pos = Source::Position.new(line, column)
+      @strings.each do |str|
+        return true if str.contain?(pos)
+        break if str.start.line > pos.line
+      end
+      false
+    end
+
+    # True if the specified location is inside a comment.
+    #
+    # @param line [Integer]
+    # @param column [Integer]
+    # @return [Boolean]
+    def comment_at?(line, column)
+      pos = Source::Position.new(line, column)
+      @comment_ranges.each do |cmnt|
+        return true if cmnt.include?(pos)
+        break if cmnt.start.line > pos.line
+      end
+      false
     end
 
     # Get an array of nodes containing the specified index, starting with the
     # nearest node and ending with the root.
     #
-    # @param index [Integer]
+    # @param line [Integer]
+    # @param column [Integer]
     # @return [Array<AST::Node>]
     def tree_at(line, column)
-      offset = Position.line_char_to_offset(@code, line, column)
+      # offset = Position.line_char_to_offset(@code, line, column)
+      position = Position.new(line, column)
       stack = []
-      inner_tree_at @node, offset, stack
+      inner_tree_at @node, position, stack
       stack
     end
 
@@ -219,8 +259,7 @@ module Solargraph
       @code = updater.write(original_code)
       @fixed = updater.write(original_code, true)
       @version = updater.version
-      return if @code == original_code
-      return unless reparse
+      return if @code == original_code or !reparse
       begin
         parse
         @fixed = @code
@@ -252,8 +291,8 @@ module Solargraph
     # @param location [Solargraph::Source::Location]
     # @return [Solargraph::Pin::Base]
     def locate_pin location
-      return nil unless location.start_with?("#{filename}:")
-      @all_pins.select{|pin| pin.location == location}.first
+      # return nil unless location.start_with?("#{filename}:")
+      pins.select{|pin| pin.location == location}
     end
 
     # @param line [Integer] A zero-based line number
@@ -284,7 +323,7 @@ module Solargraph
     def inner_node_references name, top
       result = []
       if top.kind_of?(AST::Node)
-        if (top.type == :const and top.children[1].to_s == name) or (top.type == :send and top.children[1].to_s == name)
+        if top.children.any?{|c| c.to_s == name}
           result.push top
         end
         top.children.each { |c| result.concat inner_node_references(name, c) }
@@ -292,15 +331,15 @@ module Solargraph
       result
     end
 
-    def inner_tree_at node, offset, stack
+    def inner_tree_at node, position, stack
       return if node.nil?
-      stack.unshift node
-      node.children.each do |c|
-        next unless c.is_a?(AST::Node)
-        next if c.loc.expression.nil?
-        if offset >= c.loc.expression.begin_pos and offset < c.loc.expression.end_pos
-          inner_tree_at(c, offset, stack)
-          break
+      here = Range.from_to(node.loc.expression.line, node.loc.expression.column, node.loc.expression.last_line, node.loc.expression.last_column)
+      if here.contain?(position)
+        stack.unshift node
+        node.children.each do |c|
+          next unless c.is_a?(AST::Node)
+          next if c.loc.expression.nil?
+          inner_tree_at(c, position, stack)
         end
       end
     end
@@ -327,8 +366,8 @@ module Solargraph
       parser = Parser::CurrentRuby.new(FlawedBuilder.new)
       parser.diagnostics.all_errors_are_fatal = true
       parser.diagnostics.ignore_warnings      = true
-      buffer = Parser::Source::Buffer.new(filename, 1)
-      buffer.source = code.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: ' ')
+      buffer = Parser::Source::Buffer.new(filename, 0)
+      buffer.source = code.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '_')
       parser.parse_with_comments(buffer)
     end
 
@@ -337,7 +376,9 @@ module Solargraph
       synchronize_mapped *new_map_data
     end
 
-    def synchronize_mapped new_pins, new_locals, new_requires, new_symbols #, new_path_macros, new_domains
+    def synchronize_mapped new_pins, new_locals, new_requires, new_symbols, new_strings, new_comment_ranges #, new_path_macros, new_domains
+      @strings = new_strings
+      @comment_ranges = new_comment_ranges
       return if @requires == new_requires and @symbols == new_symbols and try_merge(new_pins, new_locals)
       @pins = new_pins
       @locals = new_locals
@@ -387,7 +428,6 @@ module Solargraph
           elsif d.tag.tag_name == 'method'
             gen_src = Source.new("def #{d.tag.name};end", filename)
             gen_pin = gen_src.pins.last # Method is last pin after root namespace
-            # next if ns.nil? or ns.empty? # @todo Add methods to global namespace?
             @pins.push Solargraph::Pin::Method.new(pin.location, pin.path, gen_pin.name, docstring.all, :instance, :public, [])
           elsif d.tag.tag_name == 'macro'
             @path_macros[pin.path] = d
@@ -404,7 +444,9 @@ module Solargraph
       # @param filename [String]
       # @return [Solargraph::Source]
       def load filename
-        code = File.read(filename)
+        file = File.open(filename, 'rb')
+        code = file.read
+        file.close
         Source.load_string(code, filename)
       end
 
@@ -414,6 +456,15 @@ module Solargraph
       def load_string code, filename = nil
         Source.new code, filename
       end
+
+      def parse_node code, filename
+        parser = Parser::CurrentRuby.new(FlawedBuilder.new)
+        parser.diagnostics.all_errors_are_fatal = true
+        parser.diagnostics.ignore_warnings      = true
+        buffer = Parser::Source::Buffer.new(nil, 0)
+        buffer.source = code.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '_')
+        parser.parse(buffer)
+      end
     end
   end
 end

data/lib/solargraph/source/call_chainer.rb

@@ -0,0 +1,273 @@
+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 CallChainer
+      include NodeMethods
+
+      private_class_method :new
+
+      class << self
+        # @param source [Source]
+        # @param line [Integer]
+        # @param column [Integer]
+        # @return [Source::Chain]
+        def chain source, line, column
+          new(source, line, column).chain
+        end
+      end
+
+      # @param source [Solargraph::Source]
+      # @param line [Integer]
+      # @param column [Integer]
+      def initialize source, line, column
+        @source = source
+        # @source.code = source.code
+        @line = line
+        @column = column
+        @calculated_literal = false
+      end
+
+      # @return [Source::Chain]
+      def chain
+        links = []
+        # @todo Smelly colon handling
+        if @source.code[0..offset-1].end_with?(':') and !@source.code[0..offset-1].end_with?('::')
+          links.push Chain::Link.new
+          links.push Chain::Link.new
+        elsif @source.string_at?(line, column)
+          links.push Chain::Literal.new('String')
+        else
+          links.push Chain::Literal.new(base_literal) if base_literal?
+          sig = whole_signature
+          unless sig.empty?
+            sig = sig[1..-1] if sig.start_with?('.')
+            head = true
+            sig.split('.', -1).each do |word|
+              if word.include?('::')
+                # @todo Smelly way of handling constants
+                parts = (word.start_with?('::') ? word[2..-1] : word).split('::', -1)
+                last = parts.pop
+                links.push Chain::Constant.new(parts.join('::')) unless parts.empty?
+                links.push (last.nil? ? Chain::UNDEFINED_CONSTANT : Chain::Constant.new(last))
+              else
+                links.push word_to_link(word, head)
+              end
+              head = false
+            end
+          end
+          # Literal string hack
+          links.push Chain::UNDEFINED_CALL if base_literal? and @source.code[offset - 1] == '.' and links.length == 1
+        end
+        @chain ||= Chain.new(source.filename, links)
+      end
+
+      private
+
+      # 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 word_to_link word, head
+        if word.start_with?('@@')
+          Chain::ClassVariable.new(word)
+        elsif word.start_with?('@')
+          Chain::InstanceVariable.new(word)
+        elsif word.start_with?('$')
+          Chain::GlobalVariable.new(word)
+        elsif word.end_with?(':')
+          Chain::Link.new
+        elsif word.empty?
+          Chain::UNDEFINED_CALL
+        elsif head and !@source.code[signature_data[0]..-1].match(/^[\s]*?#{word}[\s]*?\(/)
+          # The head needs to allow for ambiguous references to constants and
+          # methods. For example, `String` might be either. If the word is not
+          # followed by an open parenthesis, use Chain::Head for ambiguous
+          # results.
+          Chain::Head.new(word)
+        else
+          Chain::Call.new(word)
+        end
+      end
+
+      # An alias for #column.
+      #
+      # @return [Integer]
+      def character
+        @column
+      end
+
+      # @return [Source::Position]
+      def position
+        @position ||= Position.new(line, column)
+      end
+
+      # Get the signature up to the current offset. Given the text `foo.bar`,
+      # the signature at offset 5 is `foo.b`.
+      #
+      # @return [String]
+      def signature
+        @signature ||= signature_data[1].to_s
+      end
+
+      # Get the remainder of the word after the current offset. Given the text
+      # `foobar` with an offset of 3, the remainder is `bar`.
+      #
+      # @return [String]
+      def remainder
+        @remainder ||= remainder_at(offset)
+      end
+
+      # Get the whole signature at the current offset, including the final
+      # word and its remainder.
+      #
+      # @return [String]
+      def whole_signature
+        @whole_signature ||= signature + remainder
+      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?(line, character)
+      end
+
+      # True if the fragment is a signature that stems from a literal value.
+      #
+      # @return [Boolean]
+      def base_literal?
+        !base_literal.nil?
+      end
+
+      # The type of literal value at the root of the signature (or nil).
+      #
+      # @return [String]
+      def base_literal
+        if @base_literal.nil? and !@calculated_literal
+          @calculated_literal = true
+          if signature.start_with?('.')
+            pn = @source.node_at(line, column - 2)
+            @base_literal = infer_literal_node_type(pn) unless pn.nil?
+          end
+        end
+        @base_literal
+      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.line, pos.character)
+          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
+              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
+
+      # @return [String]
+      def remainder_at index
+        cursor = index
+        while cursor < @source.code.length
+          char = @source.code[cursor, 1]
+          break if char.nil? or char == ''
+          break unless char.match(/[a-z0-9_\?\!]/i)
+          cursor += 1
+        end
+        @source.code[index..cursor-1].to_s
+      end
+    end
+  end
+end