solargraph 0.24.1 → 0.25.0

data/lib/solargraph/version.rb

@@ -1,3 +1,3 @@
 module Solargraph
-  VERSION = '0.24.1'
+  VERSION = '0.25.0'
 end

data/lib/solargraph/workspace.rb

@@ -9,8 +9,6 @@ module Solargraph
     # @return [String]
     attr_reader :directory
 
-    MAX_WORKSPACE_SIZE = 5000
-
     # @param directory [String]
     def initialize directory, config = nil
       # @todo Convert to an absolute path?
@@ -20,6 +18,7 @@ module Solargraph
       load_sources
     end
 
+    # @param reload [Boolean] Force a reload of the config file
     # @return [Solargraph::Workspace::Config]
     def config reload = false
       @config = Solargraph::Workspace::Config.new(directory) if @config.nil? or reload
@@ -85,15 +84,25 @@ module Solargraph
       source_hash[filename]
     end
 
+    # The time of the last workspace synchronization.
+    #
+    # @return [Time]
     def stime
       return @stime if source_hash.empty?
       @stime = source_hash.values.sort{|a, b| a.stime <=> b.stime}.last.stime
     end
 
+    # The require paths associated with the workspace.
+    #
+    # @return [Array<String>]
     def require_paths
       @require_paths ||= generate_require_paths
     end
 
+    # True if the path resolves to a file in the workspace's require paths.
+    #
+    # @param path [String]
+    # @return [Boolean]
     def would_require? path
       require_paths.each do |rp|
         return true if File.exist?(File.join(rp, "#{path}.rb"))

data/lib/solargraph/workspace/config.rb

@@ -3,6 +3,10 @@ require 'yaml'
 module Solargraph
   class Workspace
     class Config
+      # The maximum number of files that can be added to a workspace.
+      # The workspace's .solargraph.yml can override this value.
+      MAX_FILES = 5000
+
       # @return [String]
       attr_reader :workspace
 
@@ -30,7 +34,7 @@ module Solargraph
         @raw_data['domains'] ||= []
         @raw_data['reporters'] ||= %w[rubocop require_not_found]
         @raw_data['plugins'] ||= []
-        @raw_data['max_files'] ||= Workspace::MAX_WORKSPACE_SIZE
+        @raw_data['max_files'] ||= MAX_FILES
         included
         excluded
       end
@@ -58,11 +62,18 @@ module Solargraph
         @calculated ||= included - excluded
       end
 
+      # An array of domains configured for the workspace.
+      # A domain is a namespace that the ApiMap should include in the global
+      # namespace. It's typically used to identify available DSLs.
+      #
       # @return [Array<String>]
       def domains
         raw_data['domains']
       end
 
+      # An array of required paths to add to the workspace.
+      #
+      # @return [Array<String>]
       def required
         raw_data['require']
       end
@@ -71,20 +82,33 @@ module Solargraph
         raw_data['require_paths'] || []
       end
 
+      # An array of Solargraph plugins to install.
+      #
+      # @return [Array<String>]
       def plugins
         raw_data['plugins']
       end
 
+      # An array of reporters to use for diagnostics.
+      #
+      # @return [Array<String>]
       def reporters
         raw_data['reporters']
       end
 
+      # The maximum number of files to parse from the workspace.
+      #
+      # @return [Integer]
       def max_files
         raw_data['max_files']
       end
 
       private
 
+      # Get an array of files from the provided globs.
+      #
+      # @param globs [Array<String>]
+      # @return [Array<String>]
       def process_globs globs
         result = []
         globs.each do |glob|
@@ -93,6 +117,11 @@ module Solargraph
         result
       end
 
+      # Modify the included files based on excluded directories and get an
+      # array of additional files to exclude.
+      #
+      # @param globs [Array<String>]
+      # @return [Array<String>]
       def process_exclusions globs
         remainder = globs.select do |glob|
           if glob_is_directory?(glob)
@@ -106,10 +135,27 @@ module Solargraph
         process_globs remainder
       end
 
+      # True if the glob translates to a whole directory.
+      #
+      # @example
+      #   glob_is_directory?('path/to/dir')       # => true
+      #   glob_is_directory?('path/to/dir/**/*)   # => true
+      #   glob_is_directory?('path/to/file.txt')  # => false
+      #   glob_is_directory?('path/to/*.txt')     # => false
+      #
+      # @param glob [String]
+      # @return [Boolean]
       def glob_is_directory? glob
         File.directory?(glob) or File.directory?(glob_to_directory(glob))
       end
 
+      # Translate a glob to a base directory if applicable
+      #
+      # @example
+      #   glob_to_directory('path/to/dir/**/*') # => 'path/to/dir'
+      #
+      # @param glob [String]
+      # @return [String]
       def glob_to_directory glob
         glob.gsub(/(\/\*|\/\*\*\/\*\*?)$/, '')
       end

data/lib/solargraph/yard_map.rb

@@ -5,7 +5,7 @@ module Solargraph
   # stdlib, and gems.
   #
   class YardMap
-    autoload :Cache, 'solargraph/yard_map/cache'
+    autoload :Cache,    'solargraph/yard_map/cache'
     autoload :CoreDocs, 'solargraph/yard_map/core_docs'
 
     CoreDocs.require_minimum
@@ -26,25 +26,21 @@ module Solargraph
     # @return [Array<String>]
     attr_reader :required
 
-    def initialize required: [], workspace: nil
+    def initialize(required: [], workspace: nil)
       @workspace = workspace
       # HACK: YardMap needs its own copy of this array
       @required = required.clone
-      @namespace_yardocs = {}
       @gem_paths = {}
       @stdlib_namespaces = []
       process_requires
-      yardocs.push CoreDocs.yardoc_file
+      # yardocs.push CoreDocs.yardoc_file
       yardocs.uniq!
       yardocs.delete_if{ |y| y.start_with? workspace.directory } unless workspace.nil? or workspace.directory.nil?
-      yardocs.each do |y|
-        load_yardoc y
-        YARD::Registry.all(:class, :module).each do |ns|
-          @namespace_yardocs[ns.path] ||= []
-          @namespace_yardocs[ns.path].push y
-        end
-      end
-      cache_core
+    end
+
+    # @return [Array<Solargraph::Pin::Base>]
+    def pins
+      @pins ||= []
     end
 
     # @return [Array<String>]
@@ -73,281 +69,140 @@ module Solargraph
       end
     end
 
-    # @param query [String]
-    # @return [Array<String>]
-    def search query
-      found = []
-      (yardocs + [@@stdlib_yardoc]).each { |y|
-        yard = load_yardoc(y)
-        unless yard.nil?
-          yard.paths.each do |p|
-            if found.empty? or (query.include?('.') or query.include?('#')) or !(p.include?('.') or p.include?('#'))
-              found.push p if p.downcase.include?(query.downcase)
-            end
-          end
-        end
-      }
-      found.uniq
-    end
-
-    # @param query [String]
-    # @return [YARD::CodeObjects::Base]
-    def document query
-      found = []
-      (yardocs + [@@stdlib_yardoc]).each { |y|
-        yard = load_yardoc(y)
-        unless yard.nil?
-          obj = yard.at query
-          found.push obj unless obj.nil?
-        end
-      }
-      found
-    end
-
-    # @param namespace [String]
-    # @param scope [String]
-    # @return [Array<Solargraph::Pin::Base>]
-    def get_constants namespace , scope = ''
-      cached = cache.get_constants(namespace, scope)
-      return cached unless cached.nil?
-      consts = []
-      result = []
-      combined_namespaces(namespace, scope).each do |ns|
-        yardocs_documenting(ns).each do |y|
-          # @todo Getting constants from the stdlib works slightly differently
-          #   from methods
-          next if y == @@stdlib_yardoc
-          yard = load_yardoc(y)
-          unless yard.nil?
-            found = yard.at(ns)
-            consts.concat found.children unless found.nil?
-          end
-        end
-        consts.concat @stdlib_namespaces.select{|ns| ns.namespace.path == namespace}
+    # @param paths [Array<String>]
+    # @return [Boolean]
+    def change new_requires
+      if new_requires.uniq.sort == required.uniq.sort
+        false
+      else
+        required.clear
+        required.concat new_requires
+        process_requires
+        true
       end
-      consts.each { |c|
-        detail = nil
-        kind = nil
-        return_type = nil
-        if c.kind_of?(YARD::CodeObjects::ClassObject)
-          detail = 'Class'
-          return_type = "Class<#{c.to_s}>"
-        elsif c.kind_of?(YARD::CodeObjects::ModuleObject)
-          detail = 'Module'
-          return_type = "Module<#{c.to_s}>"
-        elsif c.kind_of?(YARD::CodeObjects::ConstantObject)
-          detail = 'Constant'
-        else
-          next
-        end
-        result.push Pin::YardObject.new(c, object_location(c))
-      }
-      cache.set_constants(namespace, scope, result)
-      result
     end
 
-    # @param namespace [String]
-    # @param scope [String]
-    # @param visibility [Array<Symbol>]
-    # @return [Array<Solargraph::Pin::Base>]
-    def get_methods namespace, scope = '', visibility: [:public]
-      return [] if namespace == '' and scope == ''
-      cached = cache.get_methods(namespace, scope, visibility)
-      return cached unless cached.nil?
-      meths = []
-      combined_namespaces(namespace, scope).each do |ns|
-        yardocs_documenting(ns).each do |y|
-          yard = load_yardoc(y)
-          unless yard.nil?
-            ns = nil
-            ns = find_first_resolved_object(yard, namespace, scope)
-            unless ns.nil?
-              has_new = false
-              ns.meths(scope: :class, visibility: visibility).each { |m|
-                has_new = true if m.name == 'new'
-                meths.push Pin::YardObject.new(m, object_location(m))
-              }
-              # HACK: Convert #initialize to .new
-              if visibility.include?(:public) and !has_new
-                init = ns.meths(scope: :instance).select{|m| m.to_s.split(/[\.#]/).last == 'initialize'}.first
-                unless init.nil?
-                  ip = Solargraph::Pin::YardObject.new(init, object_location(init))
-                  np = Solargraph::Pin::Method.new(ip.location, ip.namespace, 'new', ip.docstring, :class, :public, ip.parameters)
-                  meths.push np
-                end
-              end
-              # Collect superclass methods
-              if ns.kind_of?(YARD::CodeObjects::ClassObject) and !ns.superclass.nil?
-                meths += get_methods ns.superclass.to_s, '', visibility: [:public, :protected] unless ['Object', 'BasicObject', ''].include?(ns.superclass.to_s)
-              end
-            end
-          end
+    def core_pins
+      @@core_pins ||= begin
+        result = []
+        load_yardoc CoreDocs.yardoc_file
+        YARD::Registry.each do |o|
+          result.push generate_pin(o)
         end
+        result
       end
-      cache.set_methods(namespace, scope, visibility, meths)
-      meths
     end
 
-    # @param namespace [String]
-    # @param scope [String]
-    # @param visibility [Array<Symbol>]
-    # @return [Array<Solargraph::Pin::Base>]
-    def get_instance_methods namespace, scope = '', visibility: [:public]
-      return [] if namespace == '' and scope == ''
-      cached = cache.get_instance_methods(namespace, scope, visibility)
-      return cached unless cached.nil?
-      meths = []
-      combined_namespaces(namespace, scope).each do |ns|
-        yardocs_documenting(ns).each do |y|
-          yard = load_yardoc(y)
-          unless yard.nil?
-            ns = nil
-            ns = find_first_resolved_object(yard, namespace, scope)
-            unless ns.nil?
-              ns.meths(scope: :instance, visibility: visibility).each do |m|
-                n = m.to_s.split(/[\.#]/).last
-                # HACK: Exception for Module#module_function in Class
-                next if ns.name == :Class and m.path == 'Module#module_function'
-                # HACK: Special treatment for #initialize
-                next if n == 'initialize' and !visibility.include?(:private)
-                if (namespace == 'Kernel' or !m.to_s.start_with?('Kernel#')) and !m.docstring.to_s.include?(':nodoc:')
-                  meths.push Pin::YardObject.new(m, object_location(m))
-                end
-              end
-              if ns.kind_of?(YARD::CodeObjects::ClassObject) and namespace != 'Object'
-                unless ns.nil?
-                  meths += get_instance_methods(ns.superclass.to_s)
-                end
-              end
-              ns.instance_mixins.each do |m|
-                meths += get_instance_methods(m.to_s) unless m.to_s == 'Kernel'
-              end
-              # HACK: Now get the #initialize method for private requests
-              if visibility.include?(:private)
-                init = ns.meths(scope: :instance).select{|m| m.to_s.split(/[\.#]/).last == 'initialize'}.first
-                meths.push Pin::YardObject.new(init, object_location(init)) unless init.nil?
-              end
-            end
-          end
-        end
-      end
-      cache.set_instance_methods(namespace, scope, visibility, meths)
-      meths
-    end
+    private
 
-    # @param namespace [String]
-    # @param scope [String]
-    # @return [String]
-    def find_fully_qualified_namespace namespace, scope
-      unless scope.nil? or scope.empty?
-        parts = scope.split('::')
-        while parts.length > 0
-          here = "#{parts.join('::')}::#{namespace}"
-          return here unless yardocs_documenting(here).empty?
-          return here if @stdlib_namespaces.any?{|ns| ns.path == here}
-          parts.pop
-        end
-      end
-      return namespace unless yardocs_documenting(namespace).empty?
-      return namespace if @stdlib_namespaces.any?{|ns| ns.path == namespace}
-      nil
+    # @return [YardMap::Cache]
+    def cache
+      @cache ||= YardMap::Cache.new
     end
 
-    # @param path [String]
-    # @param space [String]
-    # @return [Array<Pin::YardObject>]
-    def objects path, space = ''
-      cached = cache.get_objects(path, space)
-      return cached unless cached.nil?
+    def recurse_namespace_object ns
       result = []
-      yardocs.each { |y|
-        yard = load_yardoc(y)
-        unless yard.nil?
-          obj = find_first_resolved_object(yard, path, space)
-          unless obj.nil?
-            result.push Pin::YardObject.new(obj, object_location(obj))
-          end
-        end
-      }
-      @stdlib_namespaces.each do |ns|
-        result.push Pin::YardObject.new(ns, object_location(ns)) if ns.path == path
+      ns.children.each do |c|
+        result.push generate_pin(c)
+        result.concat recurse_namespace_object(c) if c.respond_to?(:children)
       end
-      cache.set_objects(path, space, result)
       result
     end
 
-    # @param fqns [String]
-    # @return [Symbol] :class, :module, or nil
-    def get_namespace_type(fqns)
-      yardocs_documenting(fqns).each do |y|
-        yard = load_yardoc y
-        unless yard.nil?
-          obj = yard.at(fqns)
-          unless obj.nil?
-            return :class if obj.kind_of?(YARD::CodeObjects::ClassObject)
-            return :module if obj.kind_of?(YARD::CodeObjects::ModuleObject)
-            return nil
-          end
-        end
-      end
-      nil
-    end
-
-    private
-
-    # @return [Solargraph::YardMap::Cache]
-    def cache
-      @cache ||= Cache.new
-    end
-
-    def find_first_resolved_object yard, namespace, scope
-      unless scope.nil?
-        parts = scope.split('::')
-        while parts.length > 0
-          ns = yard.resolve(P(parts.join('::')), namespace, true)
-          return ns unless ns.nil?
-          parts.pop
-        end
+    def generate_pin code_object
+      location = object_location(code_object)
+      if code_object.is_a?(YARD::CodeObjects::NamespaceObject)
+        Solargraph::Pin::YardPin::Namespace.new(code_object, location)
+      elsif code_object.is_a?(YARD::CodeObjects::MethodObject)
+        Solargraph::Pin::YardPin::Method.new(code_object, location)
+      elsif code_object.is_a?(YARD::CodeObjects::ConstantObject)
+        Solargraph::Pin::YardPin::Constant.new(code_object, location)
+      else
+        nil
       end
-      yard.at(namespace)
-    end
-
-    def cache_core
-      get_constants '', ''
     end
 
     def process_requires
-      tried = []
+      pins.clear
       unresolved_requires.clear
+      stdnames = {}
       required.each do |r|
-        next if r.nil?
+        next if r.nil? or r.empty?
         next if !workspace.nil? and workspace.would_require?(r)
+        cached = cache.get_path_pins(r)
+        unless cached.nil?
+          pins.concat cached
+          next
+        end
+        result = []
         begin
           spec = Gem::Specification.find_by_path(r) || Gem::Specification.find_by_name(r.split('/').first)
           ver = spec.version.to_s
           ver = ">= 0" if ver.empty?
-          add_gem_dependencies spec
+          # @todo Ignoring dependencies for now
+          # add_gem_dependencies spec
           yd = YARD::Registry.yardoc_file_for_gem(spec.name, ver)
           @gem_paths[spec.name] = spec.full_gem_path
-          unresolved_requires.push r if yd.nil?
-          yardocs.unshift yd unless yd.nil? or yardocs.include?(yd)
+          if yd.nil?
+            unresolved_requires.push r
+          else
+            unless yardocs.include?(yd)
+              yardocs.unshift yd
+              # @todo Generate the pins
+              load_yardoc yd
+              YARD::Registry.each do |o|
+                result.push generate_pin(o)
+              end
+            end
+          end
         rescue Gem::LoadError => e
           next if !workspace.nil? and workspace.would_require?(r)
-          stdnames = []
+          stdtmp = []
           @@stdlib_paths.each_pair do |path, objects|
-            stdnames.concat objects if path == r or path.start_with?("#{r}/")
+            stdtmp.concat objects if path == r or path.start_with?("#{r}/")
           end
-          @stdlib_namespaces.concat stdnames
-          unresolved_requires.push r if stdnames.empty?
+          if stdtmp.empty?
+            unresolved_requires.push r
+          else
+            stdnames[r] = stdtmp
+          end
+        end
+        result.delete_if(&:nil?)
+        unless result.empty?
+          cache.set_path_pins r, result
+          pins.concat result
         end
       end
+      pins.concat process_stdlib(stdnames)
+      pins.concat core_pins
+    end
+
+    def process_stdlib required_namespaces
+      pins = []
+      unless required_namespaces.empty?
+        yard = load_yardoc @@stdlib_yardoc
+        done = []
+        required_namespaces.each_pair do |r, objects|
+          result = []
+          objects.each do |ns|
+            next if done.include?(ns.path)
+            done.push ns.path
+            result.push generate_pin(ns)
+            result.concat recurse_namespace_object(ns)
+          end
+          result.delete_if(&:nil?)
+          cache.set_path_pins(r, result) unless result.empty?
+          pins.concat result
+        end
+      end
+      pins
     end
 
     # @param spec [Gem::Specification]
     def add_gem_dependencies spec
       (spec.dependencies - spec.development_dependencies).each do |dep|
-        spec = Gem::Specification.find_by_name(dep.name)
-        @gem_paths[spec.name] = spec.full_gem_path unless spec.nil?
+        depspec = Gem::Specification.find_by_name(dep.name)
+        @gem_paths[spec.name] = depspec.full_gem_path unless depspec.nil?
         gy = YARD::Registry.yardoc_file_for_gem(dep.name)
         if gy.nil?
           unresolved_requires.push dep.name
@@ -357,36 +212,6 @@ module Solargraph
       end
     end
 
-    # @param namespace [String]
-    # @param scope [String]
-    # @return [Array<String>]
-    def combined_namespaces namespace, scope = ''
-      combined = [namespace]
-      unless scope.empty?
-        parts = scope.split('::')
-        until parts.empty?
-          combined.unshift parts.join('::') + '::' + namespace
-          parts.pop
-        end
-      end
-      combined
-    end
-
-    # @param namespace [String]
-    # @return [Array<String>]
-    def yardocs_documenting namespace
-      result = []
-      if namespace == ''
-        result.concat yardocs
-      else
-        result.concat @namespace_yardocs[namespace] unless @namespace_yardocs[namespace].nil?
-      end
-      if @stdlib_namespaces.map(&:path).include?(namespace)
-        result.push @@stdlib_yardoc
-      end
-      result
-    end
-
     # @param obj [YARD::CodeObjects::Base]
     # @return [Solargraph::Source::Location]
     def object_location obj