solargraph 0.12.2 → 0.13.0

data/lib/solargraph/api_map/cache.rb

@@ -10,6 +10,10 @@ module Solargraph
         @signature_types[[signature, namespace, scope]]
       end
 
+      def has_signature_type?(signature, namespace, scope)
+        @signature_types.has_key?([signature, namespace, scope])
+      end
+
       def set_signature_type signature, namespace, scope, value
         @signature_types[[signature, namespace, scope]] = value
       end

data/lib/solargraph/api_map/config.rb

@@ -29,7 +29,7 @@ module Solargraph
 
       def process_glob glob
         result = []
-        Dir[glob].each do |f|
+        Dir[File.join workspace, glob].each do |f|
           result.push File.realdirpath(f)
         end
         result

data/lib/solargraph/api_map/source.rb

@@ -0,0 +1,297 @@
+require 'parser/current'
+
+module Solargraph
+  class ApiMap
+    class Source
+      attr_reader :code
+      attr_reader :node
+      attr_reader :comments
+      attr_reader :filename
+
+      include NodeMethods
+
+      def initialize code, node, comments, filename
+        @code = code
+        root = AST::Node.new(:begin, [filename])
+        root = root.append node
+        @node = root
+        @comments = comments
+        @docstring_hash = associate_comments(node, comments)
+        @filename = filename
+        @namespace_nodes = {}
+        @all_nodes = []
+        inner_map_node @node
+      end
+
+      def namespaces
+        @namespace_nodes.keys
+      end
+
+      def namespace_nodes
+        @namespace_nodes
+      end
+
+      def namespace_includes
+        @namespace_includes ||= {}
+      end
+
+      def superclasses
+        @superclasses ||= {}
+      end
+
+      def method_pins
+        @method_pins ||= []
+      end
+
+      def attribute_pins
+        @attribute_pins ||= []
+      end
+
+      def instance_variable_pins
+        @instance_variable_pins ||= []
+      end
+
+      def class_variable_pins
+        @class_variable_pins ||= []
+      end
+
+      def constant_pins
+        @constant_pins ||= []
+      end
+
+      def symbol_pins
+        @symbol_pins ||= []
+      end
+
+      def required
+        @required ||= []
+      end
+
+      def docstring_for node
+        @docstring_hash[node.loc]
+      end
+
+      def code_for node
+        b = node.location.expression.begin.begin_pos
+        e = node.location.expression.end.end_pos
+        frag = code[b..e-1].to_s
+        frag.strip.gsub(/,$/, '')
+      end
+
+      def include? node
+        @all_nodes.include? node
+      end
+
+      private
+
+      def associate_comments node, comments
+        comment_hash = Parser::Source::Comment.associate_locations(node, comments)
+        yard_hash = {}
+        comment_hash.each_pair { |k, v|
+          ctxt = ''
+          num = nil
+          started = false
+          v.each { |l|
+            # Trim the comment and minimum leading whitespace
+            p = l.text.gsub(/^#/, '')
+            if num.nil? and !p.strip.empty?
+              num = p.index(/[^ ]/)
+              started = true
+            elsif started and !p.strip.empty?
+              cur = p.index(/[^ ]/)
+              num = cur if cur < num
+            end
+            if started
+              ctxt += "#{p[num..-1]}\n"
+            end
+          }
+          yard_hash[k] = YARD::Docstring.parser.parse(ctxt).to_docstring
+        }
+        yard_hash
+      end
+  
+      def inner_map_node node, tree = [], visibility = :public, scope = :instance, fqn = nil, stack = []
+        stack.push node
+        source = self
+        if node.kind_of?(AST::Node)
+          @all_nodes.push node
+          return if node.type == :str or node.type == :dstr
+          if node.type == :class or node.type == :module
+            visibility = :public
+            if node.children[0].kind_of?(AST::Node) and node.children[0].children[0].kind_of?(AST::Node) and node.children[0].children[0].type == :cbase
+              tree = pack_name(node.children[0])
+            else
+              tree = tree + pack_name(node.children[0])
+            end
+            fqn = tree.join('::')
+            @namespace_nodes[fqn] ||= []
+            @namespace_nodes[fqn].push node
+            if node.type == :class and !node.children[1].nil?
+              sc = unpack_name(node.children[1])
+              superclasses[fqn] = sc
+            end
+          end
+          file = source.filename
+          node.children.each do |c|
+            if c.kind_of?(AST::Node)
+              if c.type == :ivasgn
+                par = find_parent(stack, :class, :module, :def, :defs)
+                local_scope = ( (par.kind_of?(AST::Node) and par.type == :def) ? :instance : :class )
+                if c.children[1].nil?
+                  ora = find_parent(stack, :or_asgn)
+                  unless ora.nil?
+                    u = c.updated(:ivasgn, c.children + ora.children[1..-1], nil)
+                    instance_variable_pins.push Solargraph::Pin::InstanceVariable.new(self, u, fqn || '', local_scope)
+                  end
+                else
+                  instance_variable_pins.push Solargraph::Pin::InstanceVariable.new(self, c, fqn || '', local_scope)
+                end
+              elsif c.type == :cvasgn
+                if c.children[1].nil?
+                  ora = find_parent(stack, :or_asgn)
+                  unless ora.nil?
+                    u = c.updated(:cvasgn, c.children + ora.children[1..-1], nil)
+                    class_variable_pins.push Solargraph::Pin::ClassVariable.new(self, u, fqn || '')
+                  end
+                else
+                  class_variable_pins.push Solargraph::Pin::ClassVariable.new(self, c, fqn || '')
+                end
+              elsif c.type == :sym
+                symbol_pins.push Solargraph::Pin::Symbol.new(self, c, fqn)
+              elsif c.type == :casgn
+                constant_pins.push Solargraph::Pin::Constant.new(self, c, fqn)
+              else
+                unless fqn.nil?
+                  if c.kind_of?(AST::Node)
+                    if c.type == :def and c.children[0].to_s[0].match(/[a-z]/i)
+                      method_pins.push Solargraph::Pin::Method.new(source, c, fqn, scope, visibility)
+                      inner_map_node c, tree, visibility, scope, fqn, stack
+                      next
+                    elsif c.type == :defs
+                      method_pins.push Solargraph::Pin::Method.new(source, c, fqn, :class, :public)
+                      inner_map_node c, tree, :public, :class, fqn, stack
+                      next
+                    elsif c.type == :send and [:public, :protected, :private].include?(c.children[1])
+                      visibility = c.children[1]
+                    elsif c.type == :send and c.children[1] == :include #and node.type == :class
+                      namespace_includes[fqn] ||= []
+                      c.children[2..-1].each do |i|
+                        namespace_includes[fqn].push unpack_name(i)
+                      end
+                    elsif c.type == :send and [:attr_reader, :attr_writer, :attr_accessor].include?(c.children[1])
+                      c.children[2..-1].each do |a|
+                        if c.children[1] == :attr_reader or c.children[1] == :attr_accessor
+                          attribute_pins.push Solargraph::Pin::Attribute.new(self, a, fqn, :reader) #AttrPin.new(c)
+                        end
+                        if c.children[1] == :attr_writer or c.children[1] == :attr_accessor
+                          attribute_pins.push Solargraph::Pin::Attribute.new(self, a, fqn, :writer) #AttrPin.new(c)
+                        end
+                      end
+                    elsif c.type == :sclass and c.children[0].type == :self
+                      inner_map_node c, tree, :public, :class, fqn, stack
+                      next
+                    end
+                  end
+                end
+                if c.type == :send and c.children[1] == :require
+                  if c.children[2].kind_of?(AST::Node) and c.children[2].type == :str
+                    required.push c.children[2].children[0].to_s
+                  end
+                end
+                inner_map_node c, tree, visibility, scope, fqn, stack
+              end
+            end
+          end
+        end
+        stack.pop
+      end
+
+      def find_parent(stack, *types)
+        stack.reverse.each { |p|
+          return p if types.include?(p.type)
+        }
+        nil
+      end
+  
+      class << self
+        # @return [Solargraph::ApiMap::Source]
+        def load filename
+          code = File.read(filename).gsub(/\r/, '')
+          Source.virtual(filename, code)
+        end
+
+        def virtual filename, code
+          node, comments = Parser::CurrentRuby.parse_with_comments(code)
+          Source.new(code, node, comments, filename)
+        end
+
+        def fix filename, code, cursor = nil
+          tries = 0
+          code.gsub!(/\r/, '')
+          tmp = code
+          cursor = CodeMap.get_offset(code, cursor[0], cursor[1]) if cursor.kind_of?(Array)
+          fixed_cursor = false
+          begin
+            # HACK: The current file is parsed with a trailing underscore to fix
+            # incomplete trees resulting from short scripts (e.g., a lone variable
+            # assignment).
+            node, comments = Parser::CurrentRuby.parse_with_comments(tmp + "\n_")
+            #@node = self.api_map.append_node(node, @comments, filename)
+            #@parsed = tmp
+            #@code.freeze
+            #@parsed.freeze
+            Source.new(code, node, comments, filename)
+          rescue Parser::SyntaxError => e
+            if tries < 10
+              tries += 1
+              if tries == 10 and e.message.include?('token $end')
+                tmp += "\nend"
+              else
+                if !fixed_cursor and !cursor.nil? and e.message.include?('token $end') and cursor >= 2
+                  fixed_cursor = true
+                  spot = cursor - 2
+                  if tmp[cursor - 1] == '.'
+                    repl = ';'
+                  else
+                    repl = '#'
+                  end
+                else
+                  spot = e.diagnostic.location.begin_pos
+                  repl = '_'
+                  if tmp[spot] == '@' or tmp[spot] == ':'
+                    # Stub unfinished instance variables and symbols
+                    spot -= 1
+                  elsif tmp[spot - 1] == '.'
+                    # Stub unfinished method calls
+                    repl = '#' if spot == tmp.length or tmp[spot] == '\n'
+                    spot -= 2
+                  else
+                    # Stub the whole line
+                    spot = beginning_of_line_from(tmp, spot)
+                    repl = '#'
+                    if tmp[spot+1..-1].rstrip == 'end'
+                      repl= 'end;end'
+                    end
+                  end
+                end
+                tmp = tmp[0..spot] + repl + tmp[spot+repl.length+1..-1].to_s
+              end
+              retry
+            end
+            raise e
+          end
+        end
+
+        def beginning_of_line_from str, i
+          while i > 0 and str[i] != "\n"
+            i -= 1
+          end
+          if i > 0 and str[i..-1].strip == ''
+            i = beginning_of_line_from str, i -1
+          end
+          i
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/code_map.rb

@@ -6,19 +6,13 @@ module Solargraph
     # The root node of the parsed code.
     #
     # @return [AST::Node]
-    attr_accessor :node
+    attr_reader :node
 
     # The source code being analyzed.
     #
     # @return [String]
     attr_reader :code
 
-    # The source code after modification to fix syntax errors during parsing.
-    # This string will match #code if no modifications were made.
-    #
-    # @return [String]
-    attr_reader :parsed
-
     # The filename for the source code.
     #
     # @return [String]
@@ -38,59 +32,11 @@ module Solargraph
       filename = filename.gsub(File::ALT_SEPARATOR, File::SEPARATOR) unless filename.nil? or File::ALT_SEPARATOR.nil?
       @filename = filename
       @api_map = api_map
-      @code = code.gsub(/\r/, '')
-      tries = 0
-      tmp = @code
-      cursor = CodeMap.get_offset(@code, cursor[0], cursor[1]) if cursor.kind_of?(Array)
-      fixed_cursor = false
-      begin
-        # HACK: The current file is parsed with a trailing underscore to fix
-        # incomplete trees resulting from short scripts (e.g., a lone variable
-        # assignment).
-        node, @comments = Parser::CurrentRuby.parse_with_comments(tmp + "\n_")
-        @node = self.api_map.append_node(node, @comments, filename)
-        @parsed = tmp
-        @code.freeze
-        @parsed.freeze
-      rescue Parser::SyntaxError => e
-        if tries < 10
-          tries += 1
-          if tries == 10 and e.message.include?('token $end')
-            tmp += "\nend"
-          else
-            if !fixed_cursor and !cursor.nil? and e.message.include?('token $end') and cursor >= 2
-              fixed_cursor = true
-              spot = cursor - 2
-              if tmp[cursor - 1] == '.'
-                repl = ';'
-              else
-                repl = '#'
-              end
-            else
-              spot = e.diagnostic.location.begin_pos
-              repl = '_'
-              if tmp[spot] == '@' or tmp[spot] == ':'
-                # Stub unfinished instance variables and symbols
-                spot -= 1
-              elsif tmp[spot - 1] == '.'
-                # Stub unfinished method calls
-                repl = '#' if spot == tmp.length or tmp[spot] == '\n'
-                spot -= 2
-              else
-                # Stub the whole line
-                spot = beginning_of_line_from(tmp, spot)
-                repl = '#'
-                if tmp[spot+1..-1].rstrip == 'end'
-                  repl= 'end;end'
-                end
-              end
-            end
-            tmp = tmp[0..spot] + repl + tmp[spot+repl.length+1..-1].to_s
-          end
-          retry
-        end
-        raise e
-      end
+      @source = self.api_map.virtualize filename, code, cursor
+      @node = @source.node
+      @code = @source.code
+      @comments = @source.comments
+      self.api_map.refresh
     end
 
     # Get the ApiMap that was generated for this CodeMap.
@@ -98,8 +44,8 @@ module Solargraph
     # @return [Solargraph::ApiMap]
     def api_map
       @api_map ||= ApiMap.new(workspace)
-      @api_map.refresh
-      @api_map
+      #@api_map.refresh
+      #@api_map
     end
 
     # Get the offset of the specified line and column.
@@ -253,9 +199,11 @@ module Solargraph
     end
 
     def get_instance_variables_at(index)
-      node = parent_node_from(index, :def, :defs, :class, :module)
+      # @todo There are a lot of other cases that need to be handled here
+      node = parent_node_from(index, :def, :defs, :class, :module, :sclass)
       ns = namespace_at(index) || ''
-      api_map.get_instance_variables(ns, (node.type == :def ? :instance : :class))
+      scope = (node.type == :def ? :instance : :class)
+      api_map.get_instance_variables(ns, scope)
     end
 
     # Get suggestions for code completion at the specified location in the
@@ -266,64 +214,68 @@ module Solargraph
       return [] if string_at?(index) or string_at?(index - 1) or comment_at?(index)
       result = []
       signature = get_signature_at(index)
-      if index == 0 or @code[index - 1].match(/[\.\s]/)
-        type = infer_signature_at(index)
+      if signature.start_with?(':')
+        result.concat api_map.get_symbols
       else
-        if signature.include?('.')
-          last_period = @code[0..index].rindex('.')
-          if last_period.nil?
-            type = infer_signature_at(index)
-          else
-            type = infer_signature_at(last_period)
-          end  
+        if index == 0 or @code[index - 1].match(/[\.\s]/)
+          type = infer_signature_at(index)
         else
-          if signature.start_with?('@@')
-            return get_class_variables_at(index)
-          elsif signature.start_with?('@')
-            return get_instance_variables_at(index)
-          elsif signature.start_with?('$')
-            return api_map.get_global_variables
+          if signature.include?('.')
+            last_period = @code[0..index].rindex('.')
+            if last_period.nil?
+              type = infer_signature_at(index)
+            else
+              type = infer_signature_at(last_period)
+            end  
           else
-            type = infer_signature_at(index)
-          end
-        end
-      end
-      if type.nil?
-        unless signature.include?('.')
-          phrase = phrase_at(index)
-          signature = get_signature_at(index)
-          namespace = namespace_at(index)
-          if phrase.include?('::')
-            parts = phrase.split('::', -1)
-            ns = parts[0..-2].join('::')
-            if parts.last.include?('.')
-              ns = parts[0..-2].join('::') + '::' + parts.last[0..parts.last.index('.')-1]
-              result = api_map.get_methods(ns)
+            if signature.start_with?('@@')
+              return get_class_variables_at(index)
+            elsif signature.start_with?('@')
+              return get_instance_variables_at(index)
+            elsif signature.start_with?('$')
+              return api_map.get_global_variables
             else
-              result = api_map.namespaces_in(ns, namespace)
+              type = infer_signature_at(index)
             end
-          else
-            type = infer_literal_node_type(node_at(index - 2))
-            if type.nil?
-              current_namespace = namespace_at(index)
-              parts = current_namespace.to_s.split('::')
-              result += get_snippets_at(index) if with_snippets
-              result += get_local_variables_and_methods_at(index)
-              result += ApiMap.get_keywords
-              while parts.length > 0
-                ns = parts.join('::')
-                result += api_map.namespaces_in(ns, namespace)
-                parts.pop
+          end
+        end
+        if type.nil?
+          unless signature.include?('.')
+            phrase = phrase_at(index)
+            signature = get_signature_at(index)
+            namespace = namespace_at(index)
+            if phrase.include?('::')
+              parts = phrase.split('::', -1)
+              ns = parts[0..-2].join('::')
+              if parts.last.include?('.')
+                ns = parts[0..-2].join('::') + '::' + parts.last[0..parts.last.index('.')-1]
+                result = api_map.get_methods(ns)
+              else
+                result = api_map.namespaces_in(ns, namespace)
               end
-              result += api_map.namespaces_in('')
-              result += api_map.get_instance_methods('Kernel')
             else
-              result.concat api_map.get_instance_methods(type)
+              type = infer_literal_node_type(node_at(index - 2))
+              if type.nil?
+                current_namespace = namespace_at(index)
+                parts = current_namespace.to_s.split('::')
+                result += get_snippets_at(index) if with_snippets
+                result += get_local_variables_and_methods_at(index)
+                result += ApiMap.get_keywords
+                while parts.length > 0
+                  ns = parts.join('::')
+                  result += api_map.namespaces_in(ns, namespace)
+                  parts.pop
+                end
+                result += api_map.namespaces_in('')
+                result += api_map.get_instance_methods('Kernel')
+              else
+                result.concat api_map.get_instance_methods(type)
+              end
             end
           end
+        else
+          result.concat api_map.get_instance_methods(type)
         end
-      else
-        result.concat api_map.get_instance_methods(type)
       end
       result = reduce_starting_with(result, word_at(index)) if filtered
       result.uniq{|s| s.path}.sort{|a,b| a.label <=> b.label}
@@ -493,16 +445,20 @@ module Solargraph
       return nil if start.nil?
       remainder = parts[1..-1]
       if start.start_with?('@@')
-        type = api_map.infer_class_variable(start, ns_here)
-        return nil if type.nil?
-        return type if remainder.empty?
-        return api_map.infer_signature_type(remainder.join('.'), type, scope: :instance)
+        #type = api_map.infer_class_variable(start, ns_here)
+        #return nil if type.nil?
+        #return type if remainder.empty?
+        #return api_map.infer_signature_type(remainder.join('.'), type, scope: :instance)
+        cv = api_map.get_class_variables(ns_here).select{|s| s.label == start}.first
+        return cv.return_type unless cv.nil?
       elsif start.start_with?('@')
-        scope = (node.type == :def ? :instance : :scope)
-        type = api_map.infer_instance_variable(start, ns_here, scope)
-        return nil if type.nil?
-        return type if remainder.empty?
-        return api_map.infer_signature_type(remainder.join('.'), type, scope: :instance)
+        scope = (node.type == :def ? :instance : :class)
+        #type = api_map.infer_instance_variable(start, ns_here, scope)
+        #return nil if type.nil?
+        #return type if remainder.empty?
+        #return api_map.infer_signature_type(remainder.join('.'), type, scope: :instance)
+        iv = api_map.get_instance_variables(ns_here, scope).select{|s| s.label == start}.first
+        return iv.return_type unless iv.nil?
       end
       var = find_local_variable_node(start, node)
       if var.nil?
@@ -537,7 +493,7 @@ module Solargraph
 
     def get_type_comment node
       obj = nil
-      cmnt = api_map.get_comment_for(node)
+      cmnt = @source.docstring_for(node)
       unless cmnt.nil?
         tag = cmnt.tag(:type)
         obj = tag.types[0] unless tag.nil? or tag.types.empty?
@@ -806,7 +762,9 @@ module Solargraph
       while parts.length > 0
         result = api_map.find_fully_qualified_namespace("#{conc}::#{parts[0]}", namespace)
         if result.nil? or result.empty?
-          sugg = api_map.namespaces_in(conc, namespace).select{ |s| s.label == parts[0] }.first
+          #sugg = api_map.namespaces_in(conc, namespace).select{ |s| s.label == parts[0] }.first
+          bla = api_map.get_constants(conc, namespace)
+          sugg = api_map.get_constants(conc, namespace).select{|s| s.label == parts[0]}.first
           return nil if sugg.nil?
           result = sugg.return_type
           break if result.nil?
@@ -819,17 +777,6 @@ module Solargraph
         end
       end
       return result if is_constant
-      nil
-    end
-
-    def beginning_of_line_from str, i
-      while i > 0 and str[i] != "\n"
-        i -= 1
-      end
-      if i > 0 and str[i..-1].strip == ''
-        i = beginning_of_line_from str, i -1
-      end
-      i
     end
 
     def signature_index_before index