solargraph 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ef9da7f38a0665ebb95d8e779b511d54da955619
-  data.tar.gz: 4715dd2076a1497cf00cebb8456510a33f5ca43e
+  metadata.gz: 7d08698f9e91d4e08d2826494bb69eeb81fd8675
+  data.tar.gz: 4fb6952fdc4c54106ffdefa2d596ad764cc6d0c9
 SHA512:
-  metadata.gz: 7999e6032efaf061fbf36a7e9ae2b6f1b81955324c68c465bd8b17039a740cdb2015fbb71207df9ebce2235d60847a07dfca118296dcb6b7b4a05b9abe9049d2
-  data.tar.gz: 9a8632ccc9e26c082df9162f945257414562558fb65629b33b07e218399c76e7c93d43a9b31ef38465ac331f58acc1b172948245fdae10e076ebe40443300bb7
+  metadata.gz: 336d028676662a1315d4c9686c8c09a052618cf2ac0156a9fcf89e376ffcbec53b32c819ac5c9c77291c20eb88c63ed0fa3f1e19e185e5a1924e34e68651d045
+  data.tar.gz: 73d41b0eee445ad355d675ab4cff779330053130dd6fe1e85f5da21a1cd4a8373d707e60401675c8855002809bad34b1bfb8b04ff134717296120cfe9a166934

data/lib/solargraph.rb

@@ -1,5 +1,6 @@
 require 'solargraph/version'
 require 'rubygems/package'
+require 'yard'
 
 module Solargraph
   autoload :Analyzer,    'solargraph/analyzer'
@@ -38,3 +39,6 @@ unless File.exist?(version_dir)
   tar_extract.close
   #FileUtils.rm File.join(cache_dir, '2.0.0.tar.gz')
 end
+
+# Define a @type tag to be used for documenting variables
+YARD::Tags::Library.define_tag("Type", :type, :with_types_and_name)

data/lib/solargraph/api_map.rb

@@ -12,20 +12,25 @@ module Solargraph
       'nil', 'not', 'or', 'redo', 'rescue', 'retry', 'return', 'self', 'super',
       'then', 'true', 'undef', 'unless', 'until', 'when', 'while', 'yield'
     ]
-    
+
     MAPPABLE_METHODS = [
-      :include, :require, :autoload, :attr_reader, :attr_writer, :attr_accessor, :private, :public, :protected
+      :include, :extend, :require, :autoload, :attr_reader, :attr_writer, :attr_accessor, :private, :public, :protected,
+      :solargraph_include_public_methods
     ]
 
     include NodeMethods
-    
+
     attr_reader :workspace
     attr_reader :required
-    
+
     def initialize workspace = nil
       @workspace = workspace
       clear
       unless @workspace.nil?
+        extra = File.join(workspace, '.solargraph')
+        if File.exist?(extra)
+          append_file(extra)
+        end
         files = []
         opts = options
         (opts[:include] - opts[:exclude]).each { |glob|
@@ -51,18 +56,29 @@ module Solargraph
 
     def options
       o = {
-        include: ['app/**/*.rb', 'lib/**/*.rb'],
+        include: [],
         exclude: []
       }
-      yaml = File.join(workspace, '.solargraph.yml')
-      if workspace && File.exist?(yaml)
-        l = YAML.load_file(yaml)
-        o[:include].concat l['include'] unless l['include'].nil?
-        o[:exclude].concat l[:exclude] unless l['exclude'].nil?
+      unless workspace.nil?
+        yardopts_file = File.join(workspace, '.yardopts')
+        if File.exist?(yardopts_file)
+          yardopts = File.read(yardopts_file)
+          yardopts.lines.each { |line|
+            arg = line.strip
+            if !arg.start_with?('-')
+              o[:include].push arg
+            end
+          }
+        end
       end
+      o[:include].concat ['app/**/*.rb', 'lib/**/*.rb'] if o[:include].empty?
       o
     end
 
+    def yard_map
+      @yard_map ||= YardMap.new(required: required, workspace: workspace)
+    end
+
     def append_file filename
       append_source File.read(filename), filename
     end
@@ -80,6 +96,7 @@ module Solargraph
       @file_nodes[filename] = root
       @required.uniq!
       process_maps
+      root
     end
 
     def associate_comments node, comments
@@ -88,7 +105,7 @@ module Solargraph
       comment_hash.each_pair { |k, v|
         ctxt = ''
         v.each { |l|
-          ctxt += l.text.gsub(/^#/, '') + "\n"
+          ctxt += l.text.gsub(/^# /, '') + "\n"
         }
         parser = YARD::DocstringParser.new
         yard_hash[k] = parser.parse(ctxt).to_docstring
@@ -133,13 +150,12 @@ module Solargraph
     def namespaces_in name, root = ''
       result = []
       result += inner_namespaces_in(name, root, [])
-      yard = YardMap.new(required: @required, workspace: @workspace)
-      result += yard.get_constants name, root
+      result += yard_map.get_constants name, root
       fqns = find_fully_qualified_namespace(name, root)
       unless fqns.nil?
         nodes = get_namespace_nodes(fqns)
         get_include_strings_from(*nodes).each { |i|
-          result += yard.get_constants(i, root)
+          result += yard_map.get_constants(i, root)
         }
       end
       result
@@ -198,7 +214,7 @@ module Solargraph
           return name unless @namespace_map[name].nil?
           get_include_strings_from(*@file_nodes.values).each { |i|
             reroot = "#{root == '' ? '' : root + '::'}#{i}"
-            recname = find_fully_qualified_namespace name, reroot, skip
+            recname = find_fully_qualified_namespace name.to_s, reroot, skip
             return recname unless recname.nil?
           }
         else
@@ -215,11 +231,11 @@ module Solargraph
           }
         end
       end
-      nil
+      yard_map.find_fully_qualified_namespace(name, root)
     end
 
     def get_namespace_nodes(fqns)
-      return @file_nodes.values if fqns == ''
+      return @file_nodes.values if fqns == '' or fqns.nil?
       @namespace_map[fqns] || []
     end
 
@@ -259,7 +275,7 @@ module Solargraph
           if c.kind_of?(AST::Node)
             is_inst = !find_parent(c, :def).nil?
             if c.type == :ivasgn and c.children[0] and ( (scope == :instance and is_inst) or (scope != :instance and !is_inst) )
-              arr.push Suggestion.new(c.children[0], kind: Suggestion::VARIABLE)
+              arr.push Suggestion.new(c.children[0], kind: Suggestion::VARIABLE, documentation: get_comment_for(c))
             end
             arr += inner_get_instance_variables(c, scope) unless [:class, :module].include?(c.type)
           end
@@ -269,14 +285,28 @@ module Solargraph
     end
 
     def infer_instance_variable(var, namespace, scope = :instance)
+      result = nil
       vn = nil
-      if namespace_exists?(namespace)
-        get_namespace_nodes(namespace).each { |node|
+      fqns = find_fully_qualified_namespace(namespace)
+      unless fqns.nil?
+        get_namespace_nodes(fqns).each { |node|
           vn = find_instance_variable_assignment(var, node, scope)
           break unless vn.nil?
         }
       end
-      infer(vn.children[1]) unless vn.nil?
+      unless vn.nil?
+        cmnt = get_comment_for(vn)
+        unless cmnt.nil?
+          tag = cmnt.tag(:type)
+          result = tag.types[0] unless tag.nil? or tag.types.empty?
+        end
+        result = infer(vn.children[1]) if result.nil?
+        if result.nil?
+          signature = resolve_node_signature(vn.children[1])
+          result = infer_signature_type(signature, namespace || '', scope: scope)
+        end
+      end
+      result
     end
 
     def find_instance_variable_assignment(var, node, scope)
@@ -295,12 +325,56 @@ module Solargraph
       }
       nil
     end
-    
+
     def get_global_variables
       # TODO: Get them
       []
     end
-    
+
+    # Get a fully qualified namespace for the given signature.
+    # The signature should be in the form of a method chain, e.g.,
+    # method1.method2
+    #
+    # @return [String] The fully qualified namespace for the signature's type
+    #   or nil if a type could not be determined
+    def infer_signature_type signature, namespace, scope: :instance
+      parts = signature.split('.')
+      type = find_fully_qualified_namespace(namespace)
+      type ||= ''
+      top = true
+      while parts.length > 0 and !type.nil?
+        p = parts.shift
+        unless p == 'new' and scope != :instance
+          if scope == :instance
+            meths = get_instance_methods(type)
+            meths += get_methods('') if top
+          else
+            meths = get_methods(type)
+            #meths += get_methods('') if top
+          end
+          meths.delete_if{ |m| m.insert != p }
+          return nil if meths.empty?
+          type = nil
+          unless meths[0].documentation.nil?
+            match = meths[0].documentation.all.match(/@return \[([a-z0-9:_]*)/i)
+            type = find_fully_qualified_namespace(match[1]) unless match.nil?
+          end
+        end
+        scope = :instance
+        top = false
+      end
+      type
+    end
+
+    def get_method_return_value namespace, root, method, scope = :instance
+      meths = get_methods(namespace, root).delete_if{ |m| m.insert != method }
+      meths.each { |m|
+        r = get_return_tag(m)
+        return r unless r.nil?
+      }
+      nil
+    end
+
     def get_namespace_type namespace, root = ''
       type = nil
       fqns = find_fully_qualified_namespace(namespace, root)
@@ -314,16 +388,15 @@ module Solargraph
     def get_methods(namespace, root = '', visibility: [:public])
       meths = []
       meths += inner_get_methods(namespace, root, []) #unless has_yardoc?
-      yard = YardMap.new(required: @required, workspace: @workspace)
-      yard_meths = yard.get_methods(namespace, root, visibility: visibility)
+      yard_meths = yard_map.get_methods(namespace, root, visibility: visibility)
       if yard_meths.any?
         meths.concat yard_meths
       else
         type = get_namespace_type(namespace, root)
         if type == :class
-          meths += yard.get_instance_methods('Class')
+          meths += yard_map.get_instance_methods('Class')
         elsif type == :module
-          meths += yard.get_methods('Module')
+          meths += yard_map.get_methods('Module')
         end
         meths
       end
@@ -350,23 +423,23 @@ module Solargraph
     def get_instance_methods(namespace, root = '', visibility: [:public])
       meths = []
       meths += inner_get_instance_methods(namespace, root, []) #unless has_yardoc?
-      yard = YardMap.new(required: @required, workspace: @workspace)
-      yard_meths = yard.get_instance_methods(namespace, root, visibility: visibility)
+      fqns = find_fully_qualified_namespace(namespace, root)
+      yard_meths = yard_map.get_instance_methods(fqns, '', visibility: visibility)
       if yard_meths.any?
         meths.concat yard_meths
       else
         type = get_namespace_type(namespace, root)
         if type == :class
-          meths += yard.get_instance_methods('Object')
+          meths += yard_map.get_instance_methods('Object')
         elsif type == :module
-          meths += yard.get_instance_methods('Module')
+          meths += yard_map.get_instance_methods('Module')
         end
         # TODO: Look out for repeats. Consider not doing this at all.
-        sc = get_superclass(namespace, root)
-        until sc.nil?
-          meths += yard.get_instance_methods(sc, root)
-          sc = get_superclass(sc)
-        end
+        #sc = get_superclass(namespace, root)
+        #until sc.nil?
+        #  meths += yard.get_instance_methods(sc, root)
+        #  sc = get_superclass(sc)
+        #end
       end
       meths
     end
@@ -420,26 +493,39 @@ module Solargraph
               s = unpack_name(n.children[1])
               meths += inner_get_methods(s, root, skip)
             end
-            n.children.each { |c|
-              if c.kind_of?(AST::Node) and c.type == :defs
-                docstring = get_comment_for(c)
-                label = "#{c.children[1]}"
-                args = get_method_args(c)
-                label += " #{args.join(', ')}" unless args.empty?
-                meths.push Suggestion.new(label, insert: c.children[1].to_s, kind: Suggestion::METHOD, detail: 'Method', documentation: docstring) if c.children[1].to_s[0].match(/[a-z_]/i) and c.children[1] != :def
-              elsif c.kind_of?(AST::Node) and c.type == :send and c.children[1] == :include
-                # TODO: This might not be right. Should we be getting singleton methods
-                # from an include, or only from an extend?
-                i = unpack_name(c.children[2])
-                meths += inner_get_methods(i, root, skip) unless i == 'Kernel'
-              end
-            }
+            meths += inner_get_methods_from_node(n, root, skip)
           end
         #end
       }
       meths.uniq
     end
 
+    def inner_get_methods_from_node node, root, skip
+      meths = []
+      node.children.each { |c|
+        if c.kind_of?(AST::Node)
+          if c.type == :defs
+            docstring = get_comment_for(c)
+            label = "#{c.children[1]}"
+            args = get_method_args(c)
+            label += " #{args.join(', ')}" unless args.empty?
+            meths.push Suggestion.new(label, insert: c.children[1].to_s, kind: Suggestion::METHOD, detail: 'Method', documentation: docstring) if c.children[1].to_s[0].match(/[a-z_]/i) and c.children[1] != :def
+          elsif c.type == :send and c.children[1] == :include
+            # TODO: This might not be right. Should we be getting singleton methods
+            # from an include, or only from an extend?
+            i = unpack_name(c.children[2])
+            meths += inner_get_methods(i, root, skip) unless i == 'Kernel'
+          elsif c.type == :send and c.children[1] == :solargraph_include_public_methods
+            i = unpack_name(c.children[2])
+            meths += get_instance_methods(i, root, visibility: [:public])
+          else
+            meths += inner_get_methods_from_node(c, root, skip)
+          end
+        end
+      }
+      meths
+    end
+
     def inner_get_instance_methods(namespace, root, skip)
       fqns = find_fully_qualified_namespace(namespace, root)
       meths = []
@@ -481,19 +567,20 @@ module Solargraph
                   }
                 end
               end
-              get_include_strings_from(n).each { |i|
-                meths += inner_get_instance_methods(i, fqns, skip)
-              }
             }
           end
         #end
+        # This is necessary to get included modules from workspace definitions
+        get_include_strings_from(n).each { |i|
+          meths += inner_get_instance_methods(i, fqns, skip)
+        }
       }
       meths.uniq
     end
 
     def mappable?(node)
       # TODO Add node.type :casgn (constant assignment)
-      if node.kind_of?(AST::Node) and (node.type == :class or node.type == :module or node.type == :def or node.type == :defs or node.type == :ivasgn or node.type == :gvasgn or node.type == :or_asgn)
+      if node.kind_of?(AST::Node) and (node.type == :class or node.type == :module or node.type == :def or node.type == :defs or node.type == :ivasgn or node.type == :gvasgn or node.type == :lvasgn or node.type == :or_asgn)
         true
       elsif node.kind_of?(AST::Node) and node.type == :send and node.children[0] == nil and MAPPABLE_METHODS.include?(node.children[1])
         true
@@ -539,7 +626,7 @@ module Solargraph
       elsif node.type == :module
         children += node.children[0, 1]
         children += get_mappable_nodes(node.children[1..-1], comment_hash)
-      elsif node.type == :ivasgn or node.type == :gvasgn
+      elsif node.type == :ivasgn or node.type == :gvasgn or node.type == :lvasgn
         children += node.children
       elsif node.type == :send and node.children[1] == :include
         children += node.children[0,3]

data/lib/solargraph/code_map.rb

@@ -4,9 +4,9 @@ module Solargraph
   class CodeMap
     attr_accessor :node
     attr_accessor :api_map
-    
+
     include NodeMethods
-    
+
     def initialize code: '', filename: nil, workspace: nil, api_map: nil
       unless workspace.nil?
         workspace = workspace.gsub(File::ALT_SEPARATOR, File::SEPARATOR) unless File::ALT_SEPARATOR.nil?
@@ -17,11 +17,7 @@ module Solargraph
       end
       @api_map = api_map
       if @api_map.nil?
-        if workspace.nil?
-          @api_map = ApiMap.new(workspace)
-        else
-          @api_map = ApiMap.new(workspace)
-        end
+        @api_map = ApiMap.new(workspace)
       end
 
       @code = code.gsub(/\r/, '')
@@ -29,8 +25,8 @@ module Solargraph
       # Hide incomplete code to avoid syntax errors
       tmp = "#{@code}\nX".gsub(/[\.@]([\s])/, '#\1').gsub(/([\A\s]?)def([\s]*?[\n\Z])/, '\1#ef\2')
       begin
-        @node, comments = Parser::CurrentRuby.parse_with_comments(tmp)
-        @api_map.append_node(@node, comments, filename)
+        node, comments = Parser::CurrentRuby.parse_with_comments(tmp)
+        @node = @api_map.append_node(node, comments, filename)
       rescue Parser::SyntaxError => e
         if tries < 10
           tries += 1
@@ -154,14 +150,19 @@ module Solargraph
       return [] if string_at?(index)
       result = []
       phrase = phrase_at(index)
-      if phrase.start_with?('@')
-        if phrase.include?('.')
+      signature = get_signature_at(index)
+      if signature.start_with?('@')
+        parts = signature.split('.')
+        var = parts.shift
+        if parts.length > 0 or signature.end_with?('.')
           result = []
-          # TODO: Temporarily assuming one period
-          var = phrase[0..phrase.index('.')-1]
           ns = namespace_at(index)
-          obj = @api_map.infer_instance_variable(var, ns)
-          result = @api_map.get_instance_methods(obj) unless obj.nil?
+          scope = :class
+          node = parent_node_from(index, :def, :defs, :class, :module)
+          scope = :instance if !node.nil? and node.type == :def
+          obj = @api_map.infer_instance_variable(var, ns, scope)
+          type = @api_map.infer_signature_type(parts.join('.'), obj, scope: :instance)
+          result = @api_map.get_instance_methods(type) unless type.nil?
         else
           result = get_instance_variables_at(index)
         end
@@ -179,7 +180,7 @@ module Solargraph
         else
           result = @api_map.namespaces_in(ns)
         end
-      elsif phrase.include?('.')
+      elsif signature.include?('.')
         result = resolve_signature_at @code[0, index].rindex('.')
       else
         current_namespace = namespace_at(index)
@@ -198,74 +199,70 @@ module Solargraph
       result = reduce_starting_with(result, word_at(index)) if filtered
       result
     end
-    
+
+    # Find the signature at the specified index and get suggestions based
+    # on its inferred type.
+    #
+    # @return [Array<Solargraph::Suggestion>]
     def resolve_signature_at index
+      result = []
       signature = get_signature_at(index)
       ns_here = namespace_at(index)
-      parts = signature.split('.')
-      first = parts.shift
       scope = parent_node_from(index, :class, :module, :def, :defs) || @node
-      var = find_local_variable_node(first, scope)
+      parts = signature.split('.')
+      var = find_local_variable_node(parts[0], scope)
       if var.nil?
-        # It's not a locally assigned variable.
-        if ['STDERR','STDOUT','STDIN'].include?(first)
-          obj = 'IO'
-          if parts.length == 0
-            return @api_map.get_instance_methods('IO')
-          end
+        # It's not a local variable
+        fqns = @api_map.find_fully_qualified_namespace(signature, ns_here)
+        if fqns.nil?
+          # It's a method call
+          type = @api_map.infer_signature_type(signature, ns_here, scope: :class)
+          result.concat @api_map.get_instance_methods(type) unless type.nil?
         else
-          if parts.length == 0
-            # HACK: Assume that it's a constant (class or module) if it starts with an uppercase letter
-            if first[0] == first[0].upcase
-              return @api_map.get_methods(first, ns_here)
-            else
-              if scope.type == :def
-                meths = @api_map.get_instance_methods(ns_here).delete_if{|m| m.insert != first}
-                return [] if meths.empty?
-                return [] if meths[0].documentation.nil?
-                match = meths[0].documentation.all.match(/@return \[([a-z0-9:_]*)/i)
-                return [] if match[1].nil?
-                return @api_map.get_instance_methods(match[1], ns_here)
-              else
-                meths = @api_map.get_methods(ns_here).delete_if{|m| m.insert != first}
-                return [] if meths.empty?
-                return [] if meths[0].documentation.nil?
-                match = meths[0].documentation.all.match(/@return \[([a-z0-9:_]*)/i)
-                return [] if match[1].nil?
-                return @api_map.get_instance_methods(match[1], ns_here)
-              end
-            end
-          end
-          meth = parts.shift
-          if meth == 'new'
-            obj = first
+          result.concat @api_map.get_methods(fqns)
+        end
+      else
+        # It's a local variable. Get the type from the node
+        type = get_type_comment(var)
+        type = infer(var.children[1]) if type.nil?
+        if type.nil?
+          vsig = resolve_node_signature(var.children[1])
+          vparts = vsig.split('.')
+          fqns = @api_map.find_fully_qualified_namespace(vparts[0], ns_here)
+          if fqns.nil?
+            vtype = @api_map.infer_signature_type(vsig, ns_here, scope: :instance)
           else
-            obj = get_method_return_value first, ns_here, meth, :class
+            vtype = @api_map.infer_signature_type(vparts[1..-1].join('.'), fqns, scope: :class)
           end
+          fqns = @api_map.find_fully_qualified_namespace(vtype, ns_here)
+          signature = parts[1..-1].join('.')
+          type = @api_map.infer_signature_type(signature, fqns, scope: :instance)
         end
-        while parts.length > 0
-          obj = get_instance_method_return_value obj, ns_here, parts.shift
-        end
-        return @api_map.get_instance_methods(obj) unless obj.nil?
-      else
-        obj = infer(var.children[1])
-        while parts.length > 0
-          meth = parts.shift
-          obj = get_instance_method_return_value obj, ns_here, meth
+        unless type.nil?
+          lparts = signature.split('.')
+          if lparts.length > 1
+            lsig = lparts[1..-1].join('.')
+            ltype = @api_map.infer_signature_type(lsig, type, scope: :instance)
+            result.concat @api_map.get_instance_methods(ltype) unless ltype.nil?
+          else
+            result.concat @api_map.get_instance_methods(type)
+          end
         end
-        return @api_map.get_instance_methods(obj) unless obj.nil?
       end
+      result
     end
 
-    def get_method_return_value namespace, root, method, scope = :instance
-      meths = @api_map.get_methods(namespace, root).delete_if{ |m| m.insert != method }
-      meths.each { |m|
-        r = get_return_tag(m)
-        return r unless r.nil?
-      }
-      nil
+    def get_type_comment node
+      obj = nil
+      cmnt = @api_map.get_comment_for(node)
+      unless cmnt.nil?
+        tag = cmnt.tag(:type)
+        obj = tag.types[0] unless tag.nil? or tag.types.empty?
+      end
+      obj
     end
 
+    # @todo Candidate for deprecation
     def get_instance_method_return_value namespace, root, method
       meths = @api_map.get_instance_methods(namespace, root).delete_if{ |m| m.insert != method }
       meths.each { |m|
@@ -284,13 +281,6 @@ module Solargraph
     end
 
     def get_signature_at index
-      #node = node_at(index - 1)
-      #return '' unless node.type == :send
-      #parts = []
-      #build_signature(node, parts)
-      #return parts.join('.')
-
-      # TODO: Alternate rough version
       brackets = 0
       squares = 0
       parens = 0
@@ -314,7 +304,8 @@ module Solargraph
         end
         if brackets == 0 and parens == 0 and squares == 0
           break if ['"', "'", ',', ' ', "\t", "\n"].include?(char)
-          signature = char + signature if char.match(/[a-z0-9:\._]/i)
+          signature = char + signature if char.match(/[a-z0-9:\._@]/i)
+          break if char == '@'
         end
         index -= 1
       end
@@ -364,7 +355,7 @@ module Solargraph
       result += @api_map.get_methods('Kernel')
       result
     end
-    
+
     private
 
     def reduce_starting_with(suggestions, word)
@@ -379,7 +370,7 @@ module Solargraph
       node.children.each { |c|
         if c.kind_of?(AST::Node)
           if c.type == :lvasgn
-            arr.push Suggestion.new(c.children[0], kind: Suggestion::VARIABLE)
+            arr.push Suggestion.new(c.children[0], kind: Suggestion::VARIABLE, documentation: @api_map.get_comment_for(c))
           else
             arr += get_local_variables_from(c) unless [:class, :module, :def, :defs].include?(c.type)
           end
@@ -387,7 +378,7 @@ module Solargraph
       }
       arr
     end
-    
+
     def inner_node_at(index, node, arr)
       node.children.each { |c|
         if c.kind_of?(AST::Node)
@@ -406,7 +397,7 @@ module Solargraph
         end
       }
     end
-    
+
     def find_local_variable_node name, scope
       scope.children.each { |c|
         if c.kind_of?(AST::Node)
@@ -422,6 +413,6 @@ module Solargraph
       }
       nil
     end
-    
+
   end
 end

data/lib/solargraph/node_methods.rb

@@ -33,18 +33,34 @@ module Solargraph
         return 'Integer'
       elsif node.type == :float
         return 'Float'
-      elsif node.type == :send
-        if node.children[0].nil?
-          # TODO Another local variable or method or something? sheesh
-        else
-          ns = unpack_name(node.children[0])
-          if node.children[1] == :new
-            return ns
+      end
+      nil
+    end
+
+    # Get a call signature from a node.
+    # The result should be a string in the form of a method path, e.g.,
+    # String.new or variable.method.
+    #
+    # @return [String]
+    def resolve_node_signature node
+      stack_node_signature(node).join('.')
+    end
+
+    def stack_node_signature node
+      parts = []
+      if node.kind_of?(AST::Node)
+        if node.type == :send
+          unless node.children[0].nil?
+            parts = [unpack_name(node.children[0])] + parts
           end
+          parts += stack_node_signature(node.children[1])
+        else
+          parts = [unpack_name(node)] + stack_node_signature(node.children[1])
         end
-      elsif node.type == :cbase or node.type == :const
-        unpack_name node
+      else
+        parts.push node.to_s
       end
+      parts
     end
   end
 end

data/lib/solargraph/version.rb

@@ -1,3 +1,3 @@
 module Solargraph
-  VERSION = '0.4.2'
+  VERSION = '0.5.0'
 end

data/lib/solargraph/yard_map.rb

@@ -126,11 +126,11 @@ module Solargraph
         yard = YARD::Registry.load! y
         unless yard.nil?
           ns = nil
-          if scope == ''
-            ns = yard.at(namespace)
-          else
+          #if scope == ''
+          #  ns = yard.at(namespace)
+          #else
             ns = find_first_resolved_namespace(yard, namespace, scope)
-          end
+          #end
           unless ns.nil? or !ns.kind_of?(YARD::CodeObjects::NamespaceObject)
             ns.meths(scope: :class, visibility: visibility).each { |m|
               # HACK: Fix return tags in core documentation
@@ -156,11 +156,11 @@ module Solargraph
         yard = YARD::Registry.load! y
         unless yard.nil?
           ns = nil
-          if scope == ''
-            ns = yard.at(namespace)
-          else
+          #if scope == ''
+          #  ns = yard.at(namespace)
+          #else
             ns = find_first_resolved_namespace(yard, namespace, scope)
-          end
+          #end
           unless ns.nil?
             ns.meths(scope: :instance, visibility: visibility).each { |m|
               # HACK: Fix return tags in core documentation
@@ -186,6 +186,11 @@ module Solargraph
       Gem::Specification.map{ |s| s.name }.uniq
     end
 
+    def find_fully_qualified_namespace namespace, scope
+      obj = resolve(namespace, scope)
+      return obj.path unless obj.nil?
+    end
+
     private
 
     def get_method_args meth
@@ -215,7 +220,8 @@ module Solargraph
     def find_first_resolved_namespace yard, namespace, scope
       parts = scope.split('::')
       while parts.length > 0
-        ns = yard.resolve(P(scope), namespace)
+        puts "Looking for #{namespace} in #{parts.join('::')}"
+        ns = yard.resolve(P(parts.join('::')), namespace, true)
         return ns unless ns.nil?
         parts.pop
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solargraph
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Fred Snyder
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-08 00:00:00.000000000 Z
+date: 2017-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser