solargraph 0.39.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 86abdabe74326a279a6dc6c3f02ff09dc469e1e92cfd5f89ac3a3363ce47e146
+  data.tar.gz: 1772fe6f16f7531758d5c5853201b86c334eec8ef3f049ae764f6aa3d2d4c118
+SHA512:
+  metadata.gz: 6256341e8373235c53af95ab62fc61b02c2a3b755391786d6d28ae8b2373a141f8b4b875789760adfbdf333dfd020bff15d791c4d423cd90f5b96b6e8d9e2750
+  data.tar.gz: da4580767cecf3c62ad1e949a3ee0a97ac3a07785e52cacc5d53977f6ac6db8db4507c912136455646be196aa915920632e776aec98ddeb1d686868539707290

data/.gitignore

@@ -0,0 +1,9 @@
+/Gemfile.lock
+.Gemfile
+.idea
+.vscode
+.yardoc
+.solargraph.yml
+doc
+coverage
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,28 @@
+language: ruby
+rvm:
+  - 2.1
+  - 2.2
+  - 2.3
+  - 2.4
+  - 2.5
+  - 2.6
+  - 2.7
+  - jruby-head
+matrix:
+  include:
+    - rvm: 2.4
+      os: osx
+    - rvm: 2.6
+      os: osx
+    - rvm: 2.7
+      os: osx
+  allow_failures:
+    - rvm: 2.7
+      os: osx
+    - rvm: jruby-head
+      
+before_install:
+- ruby ./travis-bundler.rb
+- bundle install
+before_script: yard gems
+script: rspec

data/.yardopts

@@ -0,0 +1,2 @@
+lib/**/*.rb
+-e lib/yard-solargraph.rb

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gemspec name: 'solargraph'
+
+# Local gemfile for development tools, etc.
+local_gemfile = File.expand_path(".Gemfile", __dir__)
+instance_eval File.read local_gemfile if File.exist? local_gemfile

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017-2019 by Fred Snyder for Castwide Technologies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,104 @@
+# Solargraph
+
+## A Ruby Language Server
+
+Solargraph provides a comprehensive suite of tools for Ruby programming: intellisense, diagnostics, inline documentation, and type checking.
+
+## Online Demo
+
+A web-based demonstration of Solargraph's autocomplete is available at https://solargraph.org/demo.
+
+## Installation
+
+Install the gem from the command line:
+
+    gem install solargraph
+
+Or add it to your Gemfile:
+
+    gem 'solargraph', group: :development
+
+## Using Solargraph
+
+Plug-ins and extensions are available for the following editors:
+
+* **Visual Studio Code**
+    * Extension: https://marketplace.visualstudio.com/items?itemName=castwide.solargraph
+    * GitHub: https://github.com/castwide/vscode-solargraph
+
+* **Atom**
+    * Package: https://atom.io/packages/ruby-solargraph
+    * GitHub: https://github.com/castwide/atom-solargraph
+
+* **Vim**
+    * GitHub: https://github.com/autozimu/LanguageClient-neovim
+
+* **Emacs**
+    * GitHub: https://github.com/guskovd/emacs-solargraph
+
+* **Eclipse**
+    * Plugin: https://marketplace.eclipse.org/content/ruby-solargraph
+    * GitHub: https://github.com/PyvesB/eclipse-solargraph
+
+### Gem Support
+
+Solargraph is capable of providing code completion and documentation for gems that have YARD documentation. You can make sure your gems are documented by running `yard gems` from the command line. (YARD is included as one of Solargraph's gem dependencies. The first time you run it might take a while if you have a lot of gems installed).
+
+When editing code, a `require` call that references a gem will pull the documentation into the code maps and include the gem's API in code completion and intellisense.
+
+If your project automatically requires bundled gems (e.g., `require 'bundler/require'`), Solargraph will add all of the Gemfile's default dependecies to the map.
+
+### Type Checking
+
+As of version 0.33.0, Solargraph includes a [type checker](https://github.com/castwide/solargraph/issues/192) that uses a combination of YARD tags and code analysis to report missing type definitions. In strict mode, it performs type inference to determine whether the tags match the types it detects from code.
+
+### Updating Core Documentation
+
+The Solargraph gem ships with documentation for Ruby 2.2.2. You can download documentation for other Ruby versions from the command line.
+
+    $ solargraph list-cores      # List the installed documentation versions
+    $ solargraph available-cores # List the versions available for download
+    $ solargraph download-core   # Install the best match for your Ruby version
+    $ solargraph clear           # Reset the documentation cache
+
+### The Documentation Cache
+
+Solargraph uses a cache directory to store documentation for the Ruby core and customized documentation for certain gems. The default location is `~/.solargraph/cache`, e.g., `/home/<username>/.solargraph/cache` on Linux or `C:\Users\<username>\.solargraph` on Windows.
+
+You can change the location of the cache directory with the `SOLARGRAPH_CACHE` environment variable. This can be useful if you want the cache to comply with the XDG Base Directory Specification.
+
+### Solargraph and Bundler
+
+If you're using the language server with a project that uses Bundler, the most comprehensive way to use your bundled gems is to bundle Solargraph.
+
+In the Gemfile:
+
+    gem 'solargraph', group: :development
+
+Run `bundle install` and use `bundle exec yard gems` to generate the documentation. This process documents cached or vendored gems, or even gems that are installed from a local path.
+
+In order to make sure you're using the correct dependencies, you can start the language server with Bundler. In VS Code, there's a `solargraph.useBundler` option. Other clients will vary, but the command you probably want to run is `bundle exec solargraph socket` or `bundle exec solargraph stdio`.
+
+### Integrating Other Editors
+
+The [language server protocol](https://microsoft.github.io/language-server-protocol/specification) is the recommended way for integrating Solargraph into editors and IDEs. Clients can connect using either stdio or TCP. Language client developers should refer to [https://solargraph.org/guides/language-server](https://solargraph.org/guides/language-server).
+
+### More Information
+
+See [https://solargraph.org/guides](https://solargraph.org/guides) for more tips and tutorials about Solargraph.
+
+## Contributing to Solargraph
+
+### Bug Reports and Feature Requests
+
+[GitHub Issues](https://github.com/castwide/solargraph/issues) are the best place to ask questions, report problems, and suggest improvements.
+
+### Development
+
+Code contributions are always appreciated. Feel free to fork the repo and submit pull requests. Check for open issues that could use help. Start new issues to discuss changes that have a major impact on the code or require large time commitments.
+
+### Sponsorship and Donation
+
+Use Patreon to support ongoing development of Solargraph at [https://www.patreon.com/castwide](https://www.patreon.com/castwide).
+
+You can also make one-time donations via PayPal at [https://www.paypal.me/castwide](https://www.paypal.me/castwide).

data/Rakefile

@@ -0,0 +1,14 @@
+require 'rake'
+require 'rspec/core/rake_task'
+require 'bundler/gem_tasks'
+
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+rescue LoadError
+end
+
+desc "Open a Pry session preloaded with this library"
+task :console do
+  sh "pry -I lib -r solargraph.rb"
+end

data/SPONSORS.md

@@ -0,0 +1,9 @@
+# Sponsors
+
+Solargraph is developed and maintained by [Castwide Technologies](https://castwide.com).
+
+The following people and organizations provide funding or other resources. [Become a sponsor](https://patreon.com/castwide)
+
+## Named Sponsors
+
+- Emily Strickland

data/bin/solargraph

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'solargraph'
+
+Solargraph::Shell.start(ARGV)

data/lib/.rubocop.yml

@@ -0,0 +1,21 @@
+Layout/EndOfLine:
+  EnforcedStyle: lf
+Style/MethodDefParentheses:
+  Enabled: false
+Layout/EmptyLineAfterGuardClause:
+  Enabled: false
+Layout/SpaceAroundMethodCallOperator:
+  Enabled: true
+Lint/RaiseException:
+  Enabled: true
+Lint/StructNewOverride:
+  Enabled: true
+Style/ExponentialNotation:
+  Enabled: true
+Style/HashEachMethods:
+  Enabled: true
+Style/HashTransformKeys:
+  Enabled: true
+Style/HashTransformValues:
+  Enabled: true
+

data/lib/solargraph.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'solargraph/version'
+
+# The top-level namespace for the Solargraph code mapping, documentation,
+# static analysis, and language server libraries.
+#
+module Solargraph
+  class InvalidOffsetError <      RangeError;    end
+  class DiagnosticsError <        RuntimeError;  end
+  class FileNotFoundError <       RuntimeError;  end
+  class SourceNotAvailableError < StandardError; end
+  class ComplexTypeError        < StandardError; end
+  class WorkspaceTooLargeError <  RuntimeError;  end
+  class BundleNotFoundError <     StandardError; end
+
+  autoload :Position,         'solargraph/position'
+  autoload :Range,            'solargraph/range'
+  autoload :Location,         'solargraph/location'
+  autoload :Shell,            'solargraph/shell'
+  autoload :Source,           'solargraph/source'
+  autoload :SourceMap,        'solargraph/source_map'
+  autoload :ApiMap,           'solargraph/api_map'
+  autoload :YardMap,          'solargraph/yard_map'
+  autoload :Pin,              'solargraph/pin'
+  autoload :ServerMethods,    'solargraph/server_methods'
+  autoload :CoreFills,        'solargraph/core_fills'
+  autoload :StdlibFills,      'solargraph/stdlib_fills'
+  autoload :LanguageServer,   'solargraph/language_server'
+  autoload :Workspace,        'solargraph/workspace'
+  autoload :Page,             'solargraph/page'
+  autoload :Library,          'solargraph/library'
+  autoload :Diagnostics,      'solargraph/diagnostics'
+  autoload :ComplexType,      'solargraph/complex_type'
+  autoload :Bundle,           'solargraph/bundle'
+  autoload :Logging,          'solargraph/logging'
+  autoload :TypeChecker,      'solargraph/type_checker'
+  autoload :Environ,          'solargraph/environ'
+  autoload :Convention,       'solargraph/convention'
+  autoload :Documentor,       'solargraph/documentor'
+  autoload :Parser,           'solargraph/parser'
+
+  dir = File.dirname(__FILE__)
+  YARDOC_PATH = File.realpath(File.join(dir, '..', 'yardoc'))
+  YARD_EXTENSION_FILE = File.join(dir, 'yard-solargraph.rb')
+  VIEWS_PATH = File.join(dir, 'solargraph', 'views')
+
+  # A convenience method for Solargraph::Logging.logger.
+  #
+  # @return [Logger]
+  def self.logger
+    Solargraph::Logging.logger
+  end
+
+  # A helper method that runs Bundler.with_unbundled_env or falls back to
+  # Bundler.with_clean env for earlier versions of Bundler.
+  #
+  def self.with_clean_env &block
+    meth = if Bundler.respond_to?(:with_unbundled_env)
+      :with_unbundled_env
+    else
+      :with_clean_env
+    end
+    Bundler.send meth, &block
+  end
+end

data/lib/solargraph/api_map.rb

@@ -0,0 +1,745 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+require 'set'
+require 'pathname'
+require 'yard'
+require 'yard-solargraph'
+
+module Solargraph
+  # An aggregate provider for information about workspaces, sources, gems, and
+  # the Ruby core.
+  #
+  class ApiMap
+    autoload :Cache,          'solargraph/api_map/cache'
+    autoload :SourceToYard,   'solargraph/api_map/source_to_yard'
+    autoload :Store,          'solargraph/api_map/store'
+    autoload :BundlerMethods, 'solargraph/api_map/bundler_methods'
+
+    include SourceToYard
+    include BundlerMethods
+
+    # @return [Array<String>]
+    attr_reader :unresolved_requires
+
+    # @param pins [Array<Solargraph::Pin::Base>]
+    def initialize pins: []
+      @source_map_hash = {}
+      @cache = Cache.new
+      @mutex = Mutex.new
+      @method_alias_stack = []
+      index pins
+    end
+
+    # @param pins [Array<Pin::Base>]
+    # @return [self]
+    def index pins
+      @mutex.synchronize {
+        @source_map_hash.clear
+        @cache.clear
+        @store = Store.new(pins + YardMap.new.pins)
+        @unresolved_requires = []
+        workspace_filenames.clear
+      }
+      self
+    end
+
+    # Map a single source.
+    #
+    # @param source [Source]
+    # @return [self]
+    def map source
+      catalog Bundle.new(opened: [source])
+      self
+    end
+
+    # @param name [String]
+    # @return [YARD::Tags::MacroDirective, nil]
+    def named_macro name
+      store.named_macros[name]
+    end
+
+    # Catalog a bundle.
+    #
+    # @param bundle [Bundle]
+    # @return [self]
+    def catalog bundle
+      new_map_hash = {}
+      # Bundle always needs to be merged if it adds or removes sources
+      merged = (bundle.sources.length == source_map_hash.values.length)
+      bundle.sources.each do |source|
+        if source_map_hash.key?(source.filename)
+          if source_map_hash[source.filename].code == source.code && source_map_hash[source.filename].source.synchronized? && source.synchronized?
+            new_map_hash[source.filename] = source_map_hash[source.filename]
+          elsif !source.synchronized?
+            new_map_hash[source.filename] = source_map_hash[source.filename]
+            # @todo Smelly instance variable access
+            new_map_hash[source.filename].instance_variable_set(:@source, source)
+          else
+            map = Solargraph::SourceMap.map(source)
+            if source_map_hash[source.filename].try_merge!(map)
+              new_map_hash[source.filename] = source_map_hash[source.filename]
+            else
+              new_map_hash[source.filename] = map
+              merged = false
+            end
+          end
+        else
+          map = Solargraph::SourceMap.map(source)
+          new_map_hash[source.filename] = map
+          merged = false
+        end
+      end
+      return self if merged
+      implicit.clear
+      pins = []
+      reqs = Set.new
+      # @param map [SourceMap]
+      new_map_hash.values.each do |map|
+        implicit.merge map.environ
+        pins.concat map.pins
+        reqs.merge map.requires.map(&:name)
+      end
+      reqs.merge bundle.workspace.config.required
+      local_path_hash.clear
+      unless bundle.workspace.require_paths.empty?
+        file_keys = new_map_hash.keys
+        workspace_path = Pathname.new(bundle.workspace.directory)
+        reqs.delete_if do |r|
+          bundle.workspace.require_paths.any? do |base|
+            pn = workspace_path.join(base, "#{r}.rb").to_s
+            if file_keys.include? pn
+              local_path_hash[r] = pn
+              true
+            else
+              false
+            end
+          end
+        end
+      end
+      reqs.merge implicit.requires
+      pins.concat implicit.overrides
+      br = reqs.include?('bundler/require') ? require_from_bundle(bundle.workspace.directory) : {}
+      reqs.merge br.keys
+      yard_map.change(reqs.to_a, br, bundle.workspace.gemnames)
+      new_store = Store.new(pins + yard_map.pins)
+      @mutex.synchronize {
+        @cache.clear
+        @source_map_hash = new_map_hash
+        @store = new_store
+        @unresolved_requires = yard_map.unresolved_requires
+        workspace_filenames.clear
+        workspace_filenames.concat bundle.workspace.filenames
+      }
+      self
+    end
+
+    # @return [Environ]
+    def implicit
+      @implicit ||= Environ.new
+    end
+
+    # @return [Hash{String => String}]
+    def local_path_hash
+      @local_paths ||= {}
+    end
+
+    # @param filename [String]
+    # @param position [Position, Array(Integer, Integer)]
+    # @return [Source::Cursor]
+    def cursor_at filename, position
+      position = Position.normalize(position)
+      raise FileNotFoundError, "File not found: #{filename}" unless source_map_hash.has_key?(filename)
+      source_map_hash[filename].cursor_at(position)
+    end
+
+    # Get a clip by filename and position.
+    #
+    # @param filename [String]
+    # @param position [Position, Array(Integer, Integer)]
+    # @return [SourceMap::Clip]
+    def clip_at filename, position
+      position = Position.normalize(position)
+      SourceMap::Clip.new(self, cursor_at(filename, position))
+    end
+
+    # Create an ApiMap with a workspace in the specified directory.
+    #
+    # @param directory [String]
+    # @return [ApiMap]
+    def self.load directory
+      api_map = self.new
+      workspace = Solargraph::Workspace.new(directory)
+      api_map.catalog Bundle.new(workspace: workspace)
+      api_map
+    end
+
+    # @return [Array<Solargraph::Pin::Base>]
+    def pins
+      store.pins
+    end
+
+    # An array of pins based on Ruby keywords (`if`, `end`, etc.).
+    #
+    # @return [Array<Solargraph::Pin::Keyword>]
+    def self.keywords
+      @keywords ||= CoreFills::KEYWORDS.map{ |s|
+        Pin::Keyword.new(s)
+      }.freeze
+    end
+
+    # An array of namespace names defined in the ApiMap.
+    #
+    # @return [Set<String>]
+    def namespaces
+      store.namespaces
+    end
+
+    # True if the namespace exists.
+    #
+    # @param name [String] The namespace to match
+    # @param context [String] The context to search
+    # @return [Boolean]
+    def namespace_exists? name, context = ''
+      !qualify(name, context).nil?
+    end
+
+    # Get suggestions for constants in the specified namespace. The result
+    # may contain both constant and namespace pins.
+    #
+    # @param namespace [String] The namespace
+    # @param contexts [Array<String>] The contexts
+    # @return [Array<Solargraph::Pin::Base>]
+    def get_constants namespace, *contexts
+      namespace ||= ''
+      contexts.push '' if contexts.empty?
+      cached = cache.get_constants(namespace, contexts)
+      return cached.clone unless cached.nil?
+      skip = Set.new
+      result = []
+      contexts.each do |context|
+        fqns = qualify(namespace, context)
+        visibility = [:public]
+        visibility.push :private if fqns == context
+        result.concat inner_get_constants(fqns, visibility, skip)
+      end
+      cache.set_constants(namespace, contexts, result)
+      result
+    end
+
+    # Get a fully qualified namespace name. This method will start the search
+    # in the specified context until it finds a match for the name.
+    #
+    # @param namespace [String, nil] The namespace to match
+    # @param context [String] The context to search
+    # @return [String]
+    def qualify namespace, context = ''
+      return namespace if ['self', nil].include?(namespace)
+      cached = cache.get_qualified_namespace(namespace, context)
+      return cached.clone unless cached.nil?
+      result = if namespace.start_with?('::')
+                 inner_qualify(namespace[2..-1], '', Set.new)
+               else
+                 inner_qualify(namespace, context, Set.new)
+               end
+      cache.set_qualified_namespace(namespace, context, result)
+      result
+    end
+
+    # Get an array of instance variable pins defined in specified namespace
+    # and scope.
+    #
+    # @param namespace [String] A fully qualified namespace
+    # @param scope [Symbol] :instance or :class
+    # @return [Array<Solargraph::Pin::InstanceVariable>]
+    def get_instance_variable_pins(namespace, scope = :instance)
+      result = []
+      used = [namespace]
+      result.concat store.get_instance_variables(namespace, scope)
+      sc = qualify_lower(store.get_superclass(namespace), namespace)
+      until sc.nil? || used.include?(sc)
+        used.push sc
+        result.concat store.get_instance_variables(sc, scope)
+        sc = qualify_lower(store.get_superclass(sc), sc)
+      end
+      result
+    end
+
+    # Get an array of class variable pins for a namespace.
+    #
+    # @param namespace [String] A fully qualified namespace
+    # @return [Array<Solargraph::Pin::ClassVariable>]
+    def get_class_variable_pins(namespace)
+      prefer_non_nil_variables(store.get_class_variables(namespace))
+    end
+
+    # @return [Array<Solargraph::Pin::Base>]
+    def get_symbols
+      store.get_symbols
+    end
+
+    # @return [Array<Solargraph::Pin::GlobalVariable>]
+    def get_global_variable_pins
+      # @todo Slow version
+      pins.select{ |p| p.is_a?(Pin::GlobalVariable) }
+    end
+
+    # Get an array of methods available in a particular context.
+    #
+    # @param fqns [String] The fully qualified namespace to search for methods
+    # @param scope [Symbol] :class or :instance
+    # @param visibility [Array<Symbol>] :public, :protected, and/or :private
+    # @param deep [Boolean] True to include superclasses, mixins, etc.
+    # @return [Array<Solargraph::Pin::BaseMethod>]
+    def get_methods fqns, scope: :instance, visibility: [:public], deep: true
+      cached = cache.get_methods(fqns, scope, visibility, deep)
+      return cached.clone unless cached.nil?
+      result = []
+      skip = Set.new
+      if fqns == ''
+        # @todo Implement domains
+        implicit.domains.each do |domain|
+          type = ComplexType.try_parse(domain)
+          next if type.undefined?
+          result.concat inner_get_methods(type.name, type.scope, [:public], deep, skip)
+        end
+        result.concat inner_get_methods(fqns, :class, visibility, deep, skip)
+        result.concat inner_get_methods(fqns, :instance, visibility, deep, skip)
+        result.concat inner_get_methods('Kernel', :instance, visibility, deep, skip)
+      else
+        result.concat inner_get_methods(fqns, scope, visibility, deep, skip)
+        result.concat inner_get_methods('Kernel', :instance, [:public], deep, skip) if visibility.include?(:private)
+      end
+      resolved = resolve_method_aliases(result, visibility)
+      cache.set_methods(fqns, scope, visibility, deep, resolved)
+      resolved
+    end
+
+    # Get an array of method pins for a complex type.
+    #
+    # The type's namespace and the context should be fully qualified. If the
+    # context matches the namespace type or is a subclass of the type,
+    # protected methods are included in the results. If protected methods are
+    # included and internal is true, private methods are also included.
+    #
+    # @example
+    #   api_map = Solargraph::ApiMap.new
+    #   type = Solargraph::ComplexType.parse('String')
+    #   api_map.get_complex_type_methods(type)
+    #
+    # @param type [Solargraph::ComplexType] The complex type of the namespace
+    # @param context [String] The context from which the type is referenced
+    # @param internal [Boolean] True to include private methods
+    # @return [Array<Solargraph::Pin::Base>]
+    def get_complex_type_methods type, context = '', internal = false
+      # This method does not qualify the complex type's namespace because
+      # it can cause conflicts between similar names, e.g., `Foo` vs.
+      # `Other::Foo`. It still takes a context argument to determine whether
+      # protected and private methods are visible.
+      return [] if type.undefined? || type.void?
+      result = []
+      if type.duck_type?
+        type.select(&:duck_type?).each do |t|
+          result.push Pin::DuckMethod.new(name: t.tag[1..-1])
+        end
+        result.concat get_methods('Object')
+      else
+        unless type.nil? || type.name == 'void'
+          visibility = [:public]
+          if type.namespace == context || super_and_sub?(type.namespace, context)
+            visibility.push :protected
+            visibility.push :private if internal
+          end
+          result.concat get_methods(type.namespace, scope: type.scope, visibility: visibility)
+        end
+      end
+      result
+    end
+
+    # Get a stack of method pins for a method name in a namespace. The order
+    # of the pins corresponds to the ancestry chain, with highest precedence
+    # first.
+    #
+    # @example
+    #   api_map.get_method_stack('Subclass', 'method_name')
+    #     #=> [ <Subclass#method_name pin>, <Superclass#method_name pin> ]
+    #
+    # @param fqns [String]
+    # @param name [String]
+    # @param scope [Symbol] :instance or :class
+    # @return [Array<Solargraph::Pin::BaseMethod>]
+    def get_method_stack fqns, name, scope: :instance
+      get_methods(fqns, scope: scope, visibility: [:private, :protected, :public]).select{|p| p.name == name}
+    end
+
+    # Get an array of all suggestions that match the specified path.
+    #
+    # @deprecated Use #get_path_pins instead.
+    #
+    # @param path [String] The path to find
+    # @return [Array<Solargraph::Pin::Base>]
+    def get_path_suggestions path
+      return [] if path.nil?
+      result = []
+      result.concat store.get_path_pins(path)
+      resolve_method_aliases(result)
+    end
+
+    # Get an array of pins that match the specified path.
+    #
+    # @param path [String]
+    # @return [Array<Pin::Base>]
+    def get_path_pins path
+      get_path_suggestions(path)
+    end
+
+    # Get a list of documented paths that match the query.
+    #
+    # @example
+    #   api_map.query('str') # Results will include `String` and `Struct`
+    #
+    # @param query [String] The text to match
+    # @return [Array<String>]
+    def search query
+      rake_yard(store)
+      found = []
+      code_object_paths.each do |k|
+        if found.empty? || (query.include?('.') || query.include?('#')) || !(k.include?('.') || k.include?('#'))
+          found.push k if k.downcase.include?(query.downcase)
+        end
+      end
+      found
+    end
+
+    # Get YARD documentation for the specified path.
+    #
+    # @example
+    #   api_map.document('String#split')
+    #
+    # @param path [String] The path to find
+    # @return [Array<YARD::CodeObject::Base>]
+    def document path
+      rake_yard(store)
+      docs = []
+      docs.push code_object_at(path) unless code_object_at(path).nil?
+      docs
+    end
+
+    # Get an array of all symbols in the workspace that match the query.
+    #
+    # @param query [String]
+    # @return [Array<Pin::Base>]
+    def query_symbols query
+      result = []
+      source_map_hash.values.each do |s|
+        result.concat s.query_symbols(query)
+      end
+      result
+    end
+
+    # @param location [Solargraph::Location]
+    # @return [Array<Solargraph::Pin::Base>]
+    def locate_pins location
+      return [] if location.nil? || !source_map_hash.has_key?(location.filename)
+      source_map_hash[location.filename].locate_pins(location)
+    end
+
+    # @raise [FileNotFoundError] if the cursor's file is not in the ApiMap
+    # @param cursor [Source::Cursor]
+    # @return [SourceMap::Clip]
+    def clip cursor
+      raise FileNotFoundError, "ApiMap did not catalog #{cursor.filename}" unless source_map_hash.has_key?(cursor.filename)
+      SourceMap::Clip.new(self, cursor)
+    end
+
+    # Get an array of document symbols from a file.
+    #
+    # @param filename [String]
+    # @return [Array<Pin::Symbol>]
+    def document_symbols filename
+      return [] unless source_map_hash.has_key?(filename) # @todo Raise error?
+      source_map_hash[filename].document_symbols
+    end
+
+    # @return [Array<SourceMap>]
+    def source_maps
+      source_map_hash.values
+    end
+
+    # Get a source map by filename.
+    #
+    # @param filename [String]
+    # @return [SourceMap]
+    def source_map filename
+      raise FileNotFoundError, "Source map for `#{filename}` not found" unless source_map_hash.has_key?(filename)
+      source_map_hash[filename]
+    end
+
+    # True if the specified file was included in a bundle, i.e., it's either
+    # included in a workspace or open in a library.
+    #
+    # @param filename [String]
+    def bundled? filename
+      source_map_hash.keys.include?(filename)
+    end
+
+    # True if the specified file is included in the workspace.
+    #
+    # @param filename [String]
+    def workspaced? filename
+      workspace_filenames.include?(filename)
+    end
+
+    # @param location [Location]
+    # @return [Location]
+    def require_reference_at location
+      map = source_map(location.filename)
+      pin = map.requires.select { |pin| pin.location.range.contain?(location.range.start) }.first
+      return nil if pin.nil?
+      if local_path_hash.key?(pin.name)
+        return Location.new(local_path_hash[pin.name], Solargraph::Range.from_to(0, 0, 0, 0))
+      end
+      yard_map.require_reference(pin.name)
+    rescue FileNotFoundError
+      nil
+    end
+
+    # Check if a class is a superclass of another class.
+    #
+    # @param sup [String] The superclass
+    # @param sub [String] The subclass
+    # @return [Boolean]
+    def super_and_sub?(sup, sub)
+      fqsup = qualify(sup)
+      cls = qualify(sub)
+      until fqsup.nil? || cls.nil?
+        return true if cls == fqsup
+        cls = qualify_superclass(cls)
+      end
+      false
+    end
+
+    private
+
+    # @return [Array<String>]
+    def workspace_filenames
+      @workspace_filenames ||= []
+    end
+
+    # @return [YardMap]
+    def yard_map
+      @yard_map ||= YardMap.new
+    end
+
+    # A hash of source maps with filename keys.
+    #
+    # @return [Hash{String => SourceMap}]
+    def source_map_hash
+      @mutex.synchronize { @source_map_hash }
+    end
+
+    # @return [ApiMap::Store]
+    def store
+      @mutex.synchronize { @store }
+    end
+
+    # @return [Solargraph::ApiMap::Cache]
+    def cache
+      @mutex.synchronize { @cache }
+    end
+
+    # @param fqns [String] A fully qualified namespace
+    # @param scope [Symbol] :class or :instance
+    # @param visibility [Array<Symbol>] :public, :protected, and/or :private
+    # @param deep [Boolean]
+    # @param skip [Set<String>]
+    # @param no_core [Boolean] Skip core classes if true
+    # @return [Array<Pin::Base>]
+    def inner_get_methods fqns, scope, visibility, deep, skip, no_core = false
+      return [] if no_core && fqns =~ /^(Object|BasicObject|Class|Module|Kernel)$/
+      reqstr = "#{fqns}|#{scope}|#{visibility.sort}|#{deep}"
+      return [] if skip.include?(reqstr)
+      skip.add reqstr
+      result = []
+      if deep && scope == :instance
+        store.get_prepends(fqns).reverse.each do |im|
+          fqim = qualify(im, fqns)
+          result.concat inner_get_methods(fqim, scope, visibility, deep, skip, true) unless fqim.nil?
+        end
+      end
+      result.concat store.get_methods(fqns, scope: scope, visibility: visibility).sort{ |a, b| a.name <=> b.name }
+      if deep
+        if scope == :instance
+          store.get_includes(fqns).reverse.each do |im|
+            fqim = qualify(im, fqns)
+            result.concat inner_get_methods(fqim, scope, visibility, deep, skip, true) unless fqim.nil?
+          end
+          fqsc = qualify_superclass(fqns)
+          unless fqsc.nil?
+            result.concat inner_get_methods(fqsc, scope, visibility, true, skip, no_core) unless fqsc.nil?
+          end
+        else
+          store.get_extends(fqns).reverse.each do |em|
+            fqem = qualify(em, fqns)
+            result.concat inner_get_methods(fqem, :instance, visibility, deep, skip, true) unless fqem.nil?
+          end
+          fqsc = qualify_superclass(fqns)
+          unless fqsc.nil?
+            result.concat inner_get_methods(fqsc, scope, visibility, true, skip, true) unless fqsc.nil?
+          end
+          unless no_core || fqns.empty?
+            type = get_namespace_type(fqns)
+            result.concat inner_get_methods('Class', :instance, visibility, deep, skip, no_core) if type == :class
+            result.concat inner_get_methods('Module', :instance, visibility, deep, skip, no_core)
+          end
+        end
+        store.domains(fqns).each do |d|
+          dt = ComplexType.try_parse(d)
+          result.concat inner_get_methods(dt.namespace, dt.scope, [:public], deep, skip)
+        end
+      end
+      result
+    end
+
+    # @param fqns [String]
+    # @param visibility [Array<Symbol>]
+    # @param skip [Set<String>]
+    # @return [Array<Pin::Base>]
+    def inner_get_constants fqns, visibility, skip
+      return [] if fqns.nil? || skip.include?(fqns)
+      skip.add fqns
+      result = []
+      store.get_prepends(fqns).each do |is|
+        result.concat inner_get_constants(qualify(is, fqns), [:public], skip)
+      end
+      result.concat store.get_constants(fqns, visibility)
+                    .sort { |a, b| a.name <=> b.name }
+      store.get_includes(fqns).each do |is|
+        result.concat inner_get_constants(qualify(is, fqns), [:public], skip)
+      end
+      fqsc = qualify_superclass(fqns)
+      unless %w[Object BasicObject].include?(fqsc)
+        result.concat inner_get_constants(fqsc, [:public], skip)
+      end
+      result
+    end
+
+    # @return [Hash]
+    def path_macros
+      @path_macros ||= {}
+    end
+
+    # @param namespace [String]
+    # @param context [String]
+    # @return [String]
+    def qualify_lower namespace, context
+      qualify namespace, context.split('::')[0..-2].join('::')
+    end
+
+    def qualify_superclass fqsub
+      sup = store.get_superclass(fqsub)
+      return nil if sup.nil?
+      parts = fqsub.split('::')
+      last = parts.pop
+      parts.pop if last == sup
+      qualify(sup, parts.join('::'))
+    end
+
+    # @param name [String]
+    # @param root [String]
+    # @param skip [Set<String>]
+    # @return [String, nil]
+    def inner_qualify name, root, skip
+      return nil if name.nil?
+      return nil if skip.include?(root)
+      skip.add root
+      if name == ''
+        if root == ''
+          return ''
+        else
+          return inner_qualify(root, '', skip)
+        end
+      else
+        return name if root == '' && store.namespace_exists?(name)
+        roots = root.to_s.split('::')
+        while roots.length > 0
+          fqns = roots.join('::') + '::' + name
+          return fqns if store.namespace_exists?(fqns)
+          incs = store.get_includes(roots.join('::'))
+          incs.each do |inc|
+            foundinc = inner_qualify(name, inc, skip)
+            return foundinc unless foundinc.nil?
+          end
+          roots.pop
+        end
+        incs = store.get_includes('')
+        incs.each do |inc|
+          foundinc = inner_qualify(name, inc, skip)
+          return foundinc unless foundinc.nil?
+        end
+        return name if store.namespace_exists?(name)
+      end
+    end
+
+    # Get the namespace's type (Class or Module).
+    #
+    # @param fqns [String] A fully qualified namespace
+    # @return [Symbol, nil] :class, :module, or nil
+    def get_namespace_type fqns
+      return nil if fqns.nil?
+      # @type [Pin::Namespace, nil]
+      pin = store.get_path_pins(fqns).select{|p| p.is_a?(Pin::Namespace)}.first
+      return nil if pin.nil?
+      pin.type
+    end
+
+    # Sort an array of pins to put nil or undefined variables last.
+    #
+    # @param pins [Array<Solargraph::Pin::Base>]
+    # @return [Array<Solargraph::Pin::Base>]
+    def prefer_non_nil_variables pins
+      result = []
+      nil_pins = []
+      pins.each do |pin|
+        if pin.variable? && pin.nil_assignment?
+          nil_pins.push pin
+        else
+          result.push pin
+        end
+      end
+      result + nil_pins
+    end
+
+    # @param pins [Array<Pin::Base>]
+    # @param visibility [Array<Symbol>]
+    # @return [Array<Pin::Base>]
+    def resolve_method_aliases pins, visibility = [:public, :private, :protected]
+      result = []
+      pins.each do |pin|
+        resolved = resolve_method_alias(pin)
+        next unless visibility.include?(resolved.visibility)
+        result.push resolved
+      end
+      result
+    end
+
+    # @param pin [Pin::MethodAlias, Pin::Base]
+    # @return [Pin::BaseMethod]
+    def resolve_method_alias pin
+      return pin if !pin.is_a?(Pin::MethodAlias) || @method_alias_stack.include?(pin.path)
+      @method_alias_stack.push pin.path
+      origin = get_method_stack(pin.full_context.namespace, pin.original, scope: pin.scope).first
+      @method_alias_stack.pop
+      return pin if origin.nil?
+      Pin::Method.new(
+        location: pin.location,
+        closure: pin.closure,
+        name: pin.name,
+        comments: origin.comments,
+        scope: origin.scope,
+        visibility: origin.visibility,
+        parameters: origin.parameters
+      )
+    end
+  end
+end