rdoc 8.0.0 → 8.1.0

data/lib/rdoc/ri/driver.rb

@@ -4,119 +4,121 @@ require 'optparse'
 require_relative '../../rdoc'
 
 require_relative 'formatter' # For RubyGems backwards compatibility
-# TODO: Fix weird documentation with `require_relative`
-
-##
-# The RI driver implements the command-line ri tool.
-#
-# The driver supports:
-# * loading RI data from:
-#   * Ruby's standard library
-#   * RubyGems
-#   * ~/.rdoc
-#   * A user-supplied directory
-# * Paging output (uses RI_PAGER environment variable, PAGER environment
-#   variable or the less, more and pager programs)
-# * Interactive mode with tab-completion
-# * Abbreviated names (ri Zl shows Zlib documentation)
-# * Colorized output
-# * Merging output from multiple RI data sources
-
-class RDoc::RI::Driver
-
-  ##
-  # Base Driver error class
-
-  class Error < RDoc::RI::Error; end
-
-  ##
-  # Raised when a name isn't found in the ri data stores
-
-  class NotFoundError < Error
-
-    def initialize(klass, suggestion_proc = nil) # :nodoc:
-      @klass = klass
-      @suggestion_proc = suggestion_proc
-    end
+module RDoc
+  module RI
+    # TODO: Fix weird documentation with `require_relative`
 
     ##
-    # Name that wasn't found
+    # The RI driver implements the command-line ri tool.
+    #
+    # The driver supports:
+    # * loading RI data from:
+    #   * Ruby's standard library
+    #   * RubyGems
+    #   * ~/.rdoc
+    #   * A user-supplied directory
+    # * Paging output (uses RI_PAGER environment variable, PAGER environment
+    #   variable or the less, more and pager programs)
+    # * Interactive mode with tab-completion
+    # * Abbreviated names (ri Zl shows Zlib documentation)
+    # * Colorized output
+    # * Merging output from multiple RI data sources
+
+    class Driver
+
+      ##
+      # Base Driver error class
+
+      class Error < RI::Error; end
+
+      ##
+      # Raised when a name isn't found in the ri data stores
+
+      class NotFoundError < Error
+
+        def initialize(klass, suggestion_proc = nil) # :nodoc:
+          @klass = klass
+          @suggestion_proc = suggestion_proc
+        end
 
-    def name
-      @klass
-    end
+        ##
+        # Name that wasn't found
 
-    def message # :nodoc:
-      str = "Nothing known about #{@klass}"
-      suggestions = @suggestion_proc&.call
-      if suggestions and !suggestions.empty?
-        str += "\nDid you mean?  #{suggestions.join("\n               ")}"
+        def name
+          @klass
+        end
+
+        def message # :nodoc:
+          str = "Nothing known about #{@klass}"
+          suggestions = @suggestion_proc&.call
+          if suggestions and !suggestions.empty?
+            str += "\nDid you mean?  #{suggestions.join("\n               ")}"
+          end
+          str
+        end
       end
-      str
-    end
-  end
 
-  ##
-  # Show all method documentation following a class or module
+      ##
+      # Show all method documentation following a class or module
 
-  attr_accessor :show_all
+      attr_accessor :show_all
 
-  ##
-  # An RDoc::RI::Store for each entry in the RI path
+      ##
+      # An RDoc::RI::Store for each entry in the RI path
 
-  attr_accessor :stores
+      attr_accessor :stores
 
-  ##
-  # Controls the user of the pager vs $stdout
+      ##
+      # Controls the user of the pager vs $stdout
 
-  attr_accessor :use_stdout
+      attr_accessor :use_stdout
 
-  ##
-  # Default options for ri
+      ##
+      # Default options for ri
 
-  def self.default_options
-    options = {}
-    options[:interactive] = false
-    options[:profile]     = false
-    options[:show_all]    = false
-    options[:expand_refs] = true
-    options[:use_stdout]  = !$stdout.tty?
-    options[:width]       = 72
+      def self.default_options
+        options = {}
+        options[:interactive] = false
+        options[:profile]     = false
+        options[:show_all]    = false
+        options[:expand_refs] = true
+        options[:use_stdout]  = !$stdout.tty?
+        options[:width]       = 72
 
-    # By default all standard paths are used.
-    options[:use_system]     = true
-    options[:use_site]       = true
-    options[:use_home]       = true
-    options[:use_gems]       = true
-    options[:extra_doc_dirs] = []
+        # By default all standard paths are used.
+        options[:use_system]     = true
+        options[:use_site]       = true
+        options[:use_home]       = true
+        options[:use_gems]       = true
+        options[:extra_doc_dirs] = []
 
-    return options
-  end
+        return options
+      end
 
-  ##
-  # Dump +data_path+ using pp
+      ##
+      # Dump +data_path+ using pp
 
-  def self.dump(data_path)
-    require 'pp'
+      def self.dump(data_path)
+        require 'pp'
 
-    File.open data_path, 'rb' do |io|
-      pp Marshal.load(io.read)
-    end
-  end
+        File.open data_path, 'rb' do |io|
+          pp Marshal.load(io.read)
+        end
+      end
 
-  ##
-  # Parses +argv+ and returns a Hash of options
+      ##
+      # Parses +argv+ and returns a Hash of options
 
-  def self.process_args(argv)
-    options = default_options
+      def self.process_args(argv)
+        options = default_options
 
-    opts = OptionParser.new do |opt|
-      opt.program_name = File.basename $0
-      opt.version = RDoc::VERSION
-      opt.release = nil
-      opt.summary_indent = ' ' * 4
+        opts = OptionParser.new do |opt|
+          opt.program_name = File.basename $0
+          opt.version = VERSION
+          opt.release = nil
+          opt.summary_indent = ' ' * 4
 
-      opt.banner = <<-EOT
+          opt.banner = <<-EOT
 Usage: #{opt.program_name} [options] [name ...]
 
 Where name can be:
@@ -172,1401 +174,1404 @@ The ri pager can be set with the RI_PAGER environment variable
 or the PAGER environment variable.
       EOT
 
-      opt.separator nil
-      opt.separator "Options:"
+          opt.separator nil
+          opt.separator "Options:"
 
-      opt.separator nil
+          opt.separator nil
 
-      opt.on("--[no-]interactive", "-i",
-             "In interactive mode you can repeatedly",
-             "look up methods with autocomplete.") do |interactive|
-        options[:interactive] = interactive
-      end
+          opt.on("--[no-]interactive", "-i",
+                 "In interactive mode you can repeatedly",
+                 "look up methods with autocomplete.") do |interactive|
+            options[:interactive] = interactive
+          end
 
-      opt.separator nil
+          opt.separator nil
 
-      opt.on("--[no-]all", "-a",
-             "Show all documentation for a class or",
-             "module.") do |show_all|
-        options[:show_all] = show_all
-      end
+          opt.on("--[no-]all", "-a",
+                 "Show all documentation for a class or",
+                 "module.") do |show_all|
+            options[:show_all] = show_all
+          end
 
-      opt.separator nil
+          opt.separator nil
 
-      opt.on("--[no-]list", "-l",
-             "List classes ri knows about.") do |list|
-        options[:list] = list
-      end
+          opt.on("--[no-]list", "-l",
+                 "List classes ri knows about.") do |list|
+            options[:list] = list
+          end
 
-      opt.separator nil
+          opt.separator nil
 
-      opt.on("--[no-]pager",
-             "Send output to a pager,",
-             "rather than directly to stdout.") do |use_pager|
-        options[:use_stdout] = !use_pager
-      end
+          opt.on("--[no-]pager",
+                 "Send output to a pager,",
+                 "rather than directly to stdout.") do |use_pager|
+            options[:use_stdout] = !use_pager
+          end
 
-      opt.separator nil
+          opt.separator nil
 
-      opt.on("-T",
-             "Synonym for --no-pager.") do
-        options[:use_stdout] = true
-      end
+          opt.on("-T",
+                 "Synonym for --no-pager.") do
+            options[:use_stdout] = true
+          end
 
-      opt.separator nil
+          opt.separator nil
 
-      opt.on("--width=WIDTH", "-w", OptionParser::DecimalInteger,
-             "Set the width of the output.") do |width|
-        options[:width] = width
-      end
+          opt.on("--width=WIDTH", "-w", OptionParser::DecimalInteger,
+                 "Set the width of the output.") do |width|
+            options[:width] = width
+          end
 
-      opt.separator nil
+          opt.separator nil
 
-      opt.on("--server[=PORT]", Integer,
-             "Run RDoc server on the given port.",
-             "The default port is 8214.") do |port|
-        options[:server] = port || 8214
-      end
+          opt.on("--server[=PORT]", Integer,
+                 "Run RDoc server on the given port.",
+                 "The default port is 8214.") do |port|
+            options[:server] = port || 8214
+          end
 
-      opt.separator nil
+          opt.separator nil
 
-      formatters = RDoc::Markup.constants.grep(/^To[A-Z][a-z]+$/).sort
-      formatters = formatters.sort.map do |formatter|
-        formatter.to_s.sub('To', '').downcase
-      end
-      formatters -= %w[html label test] # remove useless output formats
-
-      opt.on("--format=NAME", "-f",
-             "Use the selected formatter.  The default",
-             "formatter is bs for paged output and ansi",
-             "otherwise.  Valid formatters are:",
-             "#{formatters.join(', ')}.", formatters) do |value|
-        options[:formatter] = RDoc::Markup.const_get "To#{value.capitalize}"
-      end
+          formatters = Markup.constants.grep(/^To[A-Z][a-z]+$/).sort
+          formatters = formatters.sort.map do |formatter|
+            formatter.to_s.sub('To', '').downcase
+          end
+          formatters -= %w[html label test] # remove useless output formats
+
+          opt.on("--format=NAME", "-f",
+                 "Use the selected formatter.  The default",
+                 "formatter is bs for paged output and ansi",
+                 "otherwise.  Valid formatters are:",
+                 "#{formatters.join(', ')}.", formatters) do |value|
+            options[:formatter] = Markup.const_get "To#{value.capitalize}"
+          end
 
-      opt.separator nil
+          opt.separator nil
 
-      opt.on("--[no-]expand-refs", "Expand rdoc-refs at the end of output") do |value|
-        options[:expand_refs] = value
-      end
+          opt.on("--[no-]expand-refs", "Expand rdoc-refs at the end of output") do |value|
+            options[:expand_refs] = value
+          end
 
-      opt.separator nil
+          opt.separator nil
 
-      opt.on("--help", "-h",
-             "Show help and exit.") do
-        puts opts
-        exit
-      end
+          opt.on("--help", "-h",
+                 "Show help and exit.") do
+            puts opts
+            exit
+          end
 
-      opt.separator nil
+          opt.separator nil
 
-      opt.on("--version", "-v",
-             "Output version information and exit.") do
-        puts "#{opts.program_name} #{opts.version}"
-        exit
-      end
+          opt.on("--version", "-v",
+                 "Output version information and exit.") do
+            puts "#{opts.program_name} #{opts.version}"
+            exit
+          end
 
-      opt.separator nil
-      opt.separator "Data source options:"
-      opt.separator nil
+          opt.separator nil
+          opt.separator "Data source options:"
+          opt.separator nil
 
-      opt.on("--[no-]list-doc-dirs",
-             "List the directories from which ri will",
-             "source documentation on stdout and exit.") do |list_doc_dirs|
-        options[:list_doc_dirs] = list_doc_dirs
-      end
+          opt.on("--[no-]list-doc-dirs",
+                 "List the directories from which ri will",
+                 "source documentation on stdout and exit.") do |list_doc_dirs|
+            options[:list_doc_dirs] = list_doc_dirs
+          end
 
-      opt.separator nil
+          opt.separator nil
 
-      opt.on("--doc-dir=DIRNAME", "-d", Array,
-             "List of directories from which to source",
-             "documentation in addition to the standard",
-             "directories.  May be repeated.") do |value|
-        value.each do |dir|
-          unless File.directory? dir then
-            raise OptionParser::InvalidArgument, "#{dir} is not a directory"
+          opt.on("--doc-dir=DIRNAME", "-d", Array,
+                 "List of directories from which to source",
+                 "documentation in addition to the standard",
+                 "directories.  May be repeated.") do |value|
+            value.each do |dir|
+              unless File.directory? dir
+                raise OptionParser::InvalidArgument, "#{dir} is not a directory"
+              end
+
+              options[:extra_doc_dirs] << File.expand_path(dir)
+            end
           end
 
-          options[:extra_doc_dirs] << File.expand_path(dir)
-        end
-      end
+          opt.separator nil
+
+          opt.on("--no-standard-docs",
+                 "Do not include documentation from",
+                 "the Ruby standard library, site_lib,",
+                 "installed gems, or ~/.rdoc.",
+                 "Use with --doc-dir.") do
+            options[:use_system] = false
+            options[:use_site] = false
+            options[:use_gems] = false
+            options[:use_home] = false
+          end
 
-      opt.separator nil
-
-      opt.on("--no-standard-docs",
-             "Do not include documentation from",
-             "the Ruby standard library, site_lib,",
-             "installed gems, or ~/.rdoc.",
-             "Use with --doc-dir.") do
-        options[:use_system] = false
-        options[:use_site] = false
-        options[:use_gems] = false
-        options[:use_home] = false
-      end
+          opt.separator nil
 
-      opt.separator nil
+          opt.on("--[no-]system",
+                 "Include documentation from Ruby's",
+                 "standard library.  Defaults to true.") do |value|
+            options[:use_system] = value
+          end
 
-      opt.on("--[no-]system",
-             "Include documentation from Ruby's",
-             "standard library.  Defaults to true.") do |value|
-        options[:use_system] = value
-      end
+          opt.separator nil
 
-      opt.separator nil
+          opt.on("--[no-]site",
+                 "Include documentation from libraries",
+                 "installed in site_lib.",
+                 "Defaults to true.") do |value|
+            options[:use_site] = value
+          end
 
-      opt.on("--[no-]site",
-             "Include documentation from libraries",
-             "installed in site_lib.",
-             "Defaults to true.") do |value|
-        options[:use_site] = value
-      end
+          opt.separator nil
 
-      opt.separator nil
+          opt.on("--[no-]gems",
+                 "Include documentation from RubyGems.",
+                 "Defaults to true.") do |value|
+            options[:use_gems] = value
+          end
 
-      opt.on("--[no-]gems",
-             "Include documentation from RubyGems.",
-             "Defaults to true.") do |value|
-        options[:use_gems] = value
-      end
+          opt.separator nil
 
-      opt.separator nil
+          opt.on("--[no-]home",
+                 "Include documentation stored in ~/.rdoc.",
+                 "Defaults to true.") do |value|
+            options[:use_home] = value
+          end
 
-      opt.on("--[no-]home",
-             "Include documentation stored in ~/.rdoc.",
-             "Defaults to true.") do |value|
-        options[:use_home] = value
-      end
+          opt.separator nil
+          opt.separator "Debug options:"
+          opt.separator nil
 
-      opt.separator nil
-      opt.separator "Debug options:"
-      opt.separator nil
+          opt.on("--[no-]profile",
+                 "Run with the ruby profiler.") do |value|
+            options[:profile] = value
+          end
 
-      opt.on("--[no-]profile",
-             "Run with the ruby profiler.") do |value|
-        options[:profile] = value
-      end
+          opt.separator nil
 
-      opt.separator nil
+          opt.on("--dump=CACHE",
+                 "Dump data from an ri cache or data file.") do |value|
+            unless File.readable?(value)
+              abort "#{value.inspect} is not readable"
+            end
 
-      opt.on("--dump=CACHE",
-             "Dump data from an ri cache or data file.") do |value|
-        unless File.readable?(value)
-          abort "#{value.inspect} is not readable"
-        end
+            if File.directory?(value)
+              abort "#{value.inspect} is a directory"
+            end
 
-        if File.directory?(value)
-          abort "#{value.inspect} is a directory"
+            options[:dump_path] = File.new(value)
+          end
         end
 
-        options[:dump_path] = File.new(value)
-      end
-    end
-
-    argv = ENV['RI'].to_s.split(' ').concat argv
+        argv = ENV['RI'].to_s.split(' ').concat argv
 
-    opts.parse! argv
+        opts.parse! argv
 
-    options[:names] = argv
+        options[:names] = argv
 
-    options[:use_stdout] ||= !$stdout.tty?
-    options[:use_stdout] ||= options[:interactive]
-    options[:width] ||= 72
+        options[:use_stdout] ||= !$stdout.tty?
+        options[:use_stdout] ||= options[:interactive]
+        options[:width] ||= 72
 
-    options
+        options
 
-  rescue OptionParser::InvalidArgument, OptionParser::InvalidOption => e
-    puts opts
-    puts
-    puts e
-    exit 1
-  end
+      rescue OptionParser::InvalidArgument, OptionParser::InvalidOption => e
+        puts opts
+        puts
+        puts e
+        exit 1
+      end
 
-  ##
-  # Runs the ri command line executable using +argv+
+      ##
+      # Runs the ri command line executable using +argv+
 
-  def self.run(argv = ARGV)
-    options = process_args argv
+      def self.run(argv = ARGV)
+        options = process_args argv
 
-    if options[:dump_path] then
-      dump options[:dump_path]
-      return
-    end
+        if options[:dump_path]
+          dump options[:dump_path]
+          return
+        end
 
-    ri = new options
-    ri.run
-  end
+        ri = new options
+        ri.run
+      end
 
-  ##
-  # Creates a new driver using +initial_options+ from ::process_args
+      ##
+      # Creates a new driver using +initial_options+ from ::process_args
 
-  def initialize(initial_options = {})
-    @paging = false
-    @classes = nil
+      def initialize(initial_options = {})
+        @paging = false
+        @classes = nil
 
-    options = self.class.default_options.update(initial_options)
+        options = self.class.default_options.update(initial_options)
 
-    @formatter_klass = options[:formatter]
+        @formatter_klass = options[:formatter]
 
-    require 'profile' if options[:profile]
+        require 'profile' if options[:profile]
 
-    @names = options[:names]
-    @list = options[:list]
+        @names = options[:names]
+        @list = options[:list]
 
-    @doc_dirs = []
-    @stores   = []
+        @doc_dirs = []
+        @stores   = []
 
-    RDoc::RI::Paths.each(options[:use_system], options[:use_site],
-                         options[:use_home], options[:use_gems],
-                         *options[:extra_doc_dirs]) do |path, type|
-      @doc_dirs << path
+        RI::Paths.each(options[:use_system], options[:use_site],
+                             options[:use_home], options[:use_gems],
+                             *options[:extra_doc_dirs]) do |path, type|
+          @doc_dirs << path
 
-      store = RDoc::RI::Store.new(RDoc::Options.new, path: path, type: type)
-      store.load_cache
-      @stores << store
-    end
+          store = RI::Store.new(Options.new, path: path, type: type)
+          store.load_cache
+          @stores << store
+        end
 
-    @list_doc_dirs = options[:list_doc_dirs]
+        @list_doc_dirs = options[:list_doc_dirs]
 
-    @interactive = options[:interactive]
-    @server      = options[:server]
-    @use_stdout  = options[:use_stdout]
-    @show_all    = options[:show_all]
-    @width       = options[:width]
-    @expand_refs = options[:expand_refs]
-  end
+        @interactive = options[:interactive]
+        @server      = options[:server]
+        @use_stdout  = options[:use_stdout]
+        @show_all    = options[:show_all]
+        @width       = options[:width]
+        @expand_refs = options[:expand_refs]
+      end
 
-  ##
-  # Adds paths for undocumented classes +also_in+ to +out+
+      ##
+      # Adds paths for undocumented classes +also_in+ to +out+
 
-  def add_also_in(out, also_in)
-    return if also_in.empty?
+      def add_also_in(out, also_in)
+        return if also_in.empty?
 
-    out << RDoc::Markup::Rule.new(1)
-    out << RDoc::Markup::Paragraph.new("Also found in:")
+        out << Markup::Rule.new(1)
+        out << Markup::Paragraph.new("Also found in:")
 
-    paths = RDoc::Markup::Verbatim.new
-    also_in.each do |store|
-      paths.parts.push store.friendly_path, "\n"
-    end
-    out << paths
-  end
+        paths = Markup::Verbatim.new
+        also_in.each do |store|
+          paths.parts.push store.friendly_path, "\n"
+        end
+        out << paths
+      end
 
-  ##
-  # Adds a class header to +out+ for class +name+ which is described in
-  # +classes+.
+      ##
+      # Adds a class header to +out+ for class +name+ which is described in
+      # +classes+.
 
-  def add_class(out, name, classes)
-    heading = if classes.all? { |klass| klass.module? } then
-                name
-              else
-                superclass = classes.map do |klass|
-                  klass.superclass unless klass.module?
-                end.compact.shift || 'Object'
+      def add_class(out, name, classes)
+        heading = if classes.all? { |klass| klass.module? }
+                    name
+                  else
+                    superclass = classes.map do |klass|
+                      klass.superclass unless klass.module?
+                    end.compact.shift || 'Object'
 
-                superclass = superclass.full_name unless String === superclass
+                    superclass = superclass.full_name unless String === superclass
 
-                "#{name} < #{superclass}"
-              end
+                    "#{name} < #{superclass}"
+                  end
 
-    out << RDoc::Markup::Heading.new(1, heading)
-    out << RDoc::Markup::BlankLine.new
-  end
+        out << Markup::Heading.new(1, heading)
+        out << Markup::BlankLine.new
+      end
 
-  ##
-  # Adds "(from ...)" to +out+ for +store+
+      ##
+      # Adds "(from ...)" to +out+ for +store+
 
-  def add_from(out, store)
-    out << RDoc::Markup::Paragraph.new("(from #{store.friendly_path})")
-  end
+      def add_from(out, store)
+        out << Markup::Paragraph.new("(from #{store.friendly_path})")
+      end
 
-  ##
-  # Adds +extends+ to +out+
+      ##
+      # Adds +extends+ to +out+
 
-  def add_extends(out, extends)
-    add_extension_modules out, 'Extended by', extends
-  end
+      def add_extends(out, extends)
+        add_extension_modules out, 'Extended by', extends
+      end
 
-  ##
-  # Adds a list of +extensions+ to this module of the given +type+ to +out+.
-  # add_includes and add_extends call this, so you should use those directly.
+      ##
+      # Adds a list of +extensions+ to this module of the given +type+ to +out+.
+      # add_includes and add_extends call this, so you should use those directly.
 
-  def add_extension_modules(out, type, extensions)
-    return if extensions.empty?
+      def add_extension_modules(out, type, extensions)
+        return if extensions.empty?
 
-    out << RDoc::Markup::Rule.new(1)
-    out << RDoc::Markup::Heading.new(1, "#{type}:")
+        out << Markup::Rule.new(1)
+        out << Markup::Heading.new(1, "#{type}:")
 
-    extensions.each do |modules, store|
-      if modules.length == 1 then
-        add_extension_modules_single out, store, modules.first
-      else
-        add_extension_modules_multiple out, store, modules
+        extensions.each do |modules, store|
+          if modules.length == 1
+            add_extension_modules_single out, store, modules.first
+          else
+            add_extension_modules_multiple out, store, modules
+          end
+        end
       end
-    end
-  end
 
-  ##
-  # Renders multiple included +modules+ from +store+ to +out+.
+      ##
+      # Renders multiple included +modules+ from +store+ to +out+.
 
-  def add_extension_modules_multiple(out, store, modules) # :nodoc:
-    out << RDoc::Markup::Paragraph.new("(from #{store.friendly_path})")
+      def add_extension_modules_multiple(out, store, modules) # :nodoc:
+        out << Markup::Paragraph.new("(from #{store.friendly_path})")
 
-    wout, with = modules.partition { |incl| incl.comment.empty? }
+        wout, with = modules.partition { |incl| incl.comment.empty? }
 
-    out << RDoc::Markup::BlankLine.new unless with.empty?
+        out << Markup::BlankLine.new unless with.empty?
 
-    with.each do |incl|
-      out << RDoc::Markup::Paragraph.new(incl.name)
-      out << RDoc::Markup::BlankLine.new
-      out << incl.comment.parse
-    end
+        with.each do |incl|
+          out << Markup::Paragraph.new(incl.name)
+          out << Markup::BlankLine.new
+          out << incl.comment.parse
+        end
 
-    unless wout.empty? then
-      verb = RDoc::Markup::Verbatim.new
+        unless wout.empty?
+          verb = Markup::Verbatim.new
 
-      wout.each do |incl|
-        verb.push incl.name, "\n"
-      end
+          wout.each do |incl|
+            verb.push incl.name, "\n"
+          end
 
-      out << verb
-    end
-  end
+          out << verb
+        end
+      end
 
-  ##
-  # Adds a single extension module +include+ from +store+ to +out+
+      ##
+      # Adds a single extension module +include+ from +store+ to +out+
 
-  def add_extension_modules_single(out, store, include) # :nodoc:
-    name = include.name
-    path = store.friendly_path
-    out << RDoc::Markup::Paragraph.new("#{name} (from #{path})")
+      def add_extension_modules_single(out, store, include) # :nodoc:
+        name = include.name
+        path = store.friendly_path
+        out << Markup::Paragraph.new("#{name} (from #{path})")
 
-    if include.comment then
-      out << RDoc::Markup::BlankLine.new
-      out << include.comment.parse
-    end
-  end
+        if include.comment
+          out << Markup::BlankLine.new
+          out << include.comment.parse
+        end
+      end
 
-  ##
-  # Adds +includes+ to +out+
+      ##
+      # Adds +includes+ to +out+
 
-  def add_includes(out, includes)
-    add_extension_modules out, 'Includes', includes
-  end
+      def add_includes(out, includes)
+        add_extension_modules out, 'Includes', includes
+      end
 
-  ##
-  # Looks up the method +name+ and adds it to +out+
+      ##
+      # Looks up the method +name+ and adds it to +out+
 
-  def add_method(out, name)
-    filtered = lookup_method name
-    method_document out, name, filtered
-  end
+      def add_method(out, name)
+        filtered = lookup_method name
+        method_document out, name, filtered
+      end
 
-  ##
-  # Adds documentation for all methods in +klass+ to +out+
+      ##
+      # Adds documentation for all methods in +klass+ to +out+
 
-  def add_method_documentation(out, klass)
-    klass.method_list.each do |method|
-      begin
-        add_method out, method.full_name
-      rescue NotFoundError
-        next
+      def add_method_documentation(out, klass)
+        klass.method_list.each do |method|
+          begin
+            add_method out, method.full_name
+          rescue NotFoundError
+            next
+          end
+        end
       end
-    end
-  end
 
-  ##
-  # Adds a list of +methods+ to +out+ with a heading of +name+
+      ##
+      # Adds a list of +methods+ to +out+ with a heading of +name+
 
-  def add_method_list(out, methods, name)
-    return if methods.empty?
+      def add_method_list(out, methods, name)
+        return if methods.empty?
 
-    out << RDoc::Markup::Heading.new(1, "#{name}:")
-    out << RDoc::Markup::BlankLine.new
+        out << Markup::Heading.new(1, "#{name}:")
+        out << Markup::BlankLine.new
 
-    if @use_stdout and !@interactive then
-      out.concat methods.map { |method|
-        RDoc::Markup::Verbatim.new method
-      }
-    else
-      out << RDoc::Markup::IndentedParagraph.new(2, methods.join(', '))
-    end
+        if @use_stdout and !@interactive
+          out.concat methods.map { |method|
+            Markup::Verbatim.new method
+          }
+        else
+          out << Markup::IndentedParagraph.new(2, methods.join(', '))
+        end
 
-    out << RDoc::Markup::BlankLine.new
-  end
+        out << Markup::BlankLine.new
+      end
 
-  ##
-  # Returns ancestor classes of +klass+
+      ##
+      # Returns ancestor classes of +klass+
 
-  def ancestors_of(klass)
-    ancestors = []
+      def ancestors_of(klass)
+        ancestors = []
 
-    unexamined = [klass]
-    seen = []
+        unexamined = [klass]
+        seen = []
 
-    loop do
-      break if unexamined.empty?
-      current = unexamined.shift
-      seen << current
+        loop do
+          break if unexamined.empty?
+          current = unexamined.shift
+          seen << current
 
-      stores = classes[current]
+          stores = classes[current]
 
-      next unless stores and not stores.empty?
+          next unless stores and not stores.empty?
 
-      klasses = stores.flat_map do |store|
-        store.ancestors[current] || []
-      end.uniq
+          klasses = stores.flat_map do |store|
+            store.ancestors[current] || []
+          end.uniq
 
-      klasses = klasses - seen
+          klasses = klasses - seen
 
-      ancestors.concat klasses
-      unexamined.concat klasses
-    end
+          ancestors.concat klasses
+          unexamined.concat klasses
+        end
 
-    ancestors.reverse
-  end
+        ancestors.reverse
+      end
 
-  ##
-  # For RubyGems backwards compatibility
+      ##
+      # For RubyGems backwards compatibility
 
-  def class_cache # :nodoc:
-  end
+      def class_cache # :nodoc:
+      end
 
-  ##
-  # Builds a RDoc::Markup::Document from +found+, +klasess+ and +includes+
+      ##
+      # Builds a RDoc::Markup::Document from +found+, +klasess+ and +includes+
 
-  def class_document(name, found, klasses, includes, extends)
-    also_in = []
+      def class_document(name, found, klasses, includes, extends)
+        also_in = []
 
-    out = RDoc::Markup::Document.new
+        out = Markup::Document.new
 
-    add_class out, name, klasses
+        add_class out, name, klasses
 
-    add_includes out, includes
-    add_extends  out, extends
+        add_includes out, includes
+        add_extends  out, extends
 
-    found.each do |store, klass|
-      render_class out, store, klass, also_in
-    end
+        found.each do |store, klass|
+          render_class out, store, klass, also_in
+        end
 
-    add_also_in out, also_in
+        add_also_in out, also_in
 
-    expand_rdoc_refs_at_the_bottom(out)
-    out
-  end
+        expand_rdoc_refs_at_the_bottom(out)
+        out
+      end
 
-  ##
-  # Adds the class +comment+ to +out+.
+      ##
+      # Adds the class +comment+ to +out+.
 
-  def class_document_comment(out, document) # :nodoc:
-    unless document.empty? then
-      out << RDoc::Markup::Rule.new(1)
+      def class_document_comment(out, document) # :nodoc:
+        unless document.empty?
+          out << Markup::Rule.new(1)
 
-      if document.merged? then
-        parts = document.parts
-        parts = parts.zip [RDoc::Markup::BlankLine.new] * parts.length
-        parts.flatten!
-        parts.pop
+          if document.merged?
+            parts = document.parts
+            parts = parts.zip [Markup::BlankLine.new] * parts.length
+            parts.flatten!
+            parts.pop
 
-        out.concat parts
-      else
-        out << comment
+            out.concat parts
+          else
+            out << comment
+          end
+        end
       end
-    end
-  end
 
-  ##
-  # Adds the constants from +klass+ to the Document +out+.
+      ##
+      # Adds the constants from +klass+ to the Document +out+.
 
-  def class_document_constants(out, klass) # :nodoc:
-    return if klass.constants.empty?
+      def class_document_constants(out, klass) # :nodoc:
+        return if klass.constants.empty?
 
-    out << RDoc::Markup::Heading.new(1, "Constants:")
-    out << RDoc::Markup::BlankLine.new
-    list = RDoc::Markup::List.new :NOTE
+        out << Markup::Heading.new(1, "Constants:")
+        out << Markup::BlankLine.new
+        list = Markup::List.new :NOTE
 
-    constants = klass.constants.sort_by { |constant| constant.name }
+        constants = klass.constants.sort_by { |constant| constant.name }
 
-    list.items.concat constants.map { |constant|
-      parts = constant.comment.parse.parts
-      parts << RDoc::Markup::Paragraph.new('[not documented]') if
-        parts.empty?
+        list.items.concat constants.map { |constant|
+          parts = constant.comment.parse.parts
+          parts << Markup::Paragraph.new('[not documented]') if
+            parts.empty?
 
-      RDoc::Markup::ListItem.new(constant.name, *parts)
-    }
+          Markup::ListItem.new(constant.name, *parts)
+        }
 
-    out << list
-    out << RDoc::Markup::BlankLine.new
-  end
+        out << list
+        out << Markup::BlankLine.new
+      end
 
-  ##
-  # Hash mapping a known class or module to the stores it can be loaded from
+      ##
+      # Hash mapping a known class or module to the stores it can be loaded from
 
-  def classes
-    return @classes if @classes
+      def classes
+        return @classes if @classes
 
-    @classes = {}
+        @classes = {}
 
-    @stores.each do |store|
-      store.cache[:modules].each do |mod|
-        # using default block causes searched-for modules to be added
-        @classes[mod] ||= []
-        @classes[mod] << store
-      end
-    end
-
-    @classes
-  end
+        @stores.each do |store|
+          store.cache[:modules].each do |mod|
+            # using default block causes searched-for modules to be added
+            @classes[mod] ||= []
+            @classes[mod] << store
+          end
+        end
 
-  ##
-  # Returns the stores wherein +name+ is found along with the classes,
-  # extends and includes that match it
-
-  def classes_and_includes_and_extends_for(name)
-    klasses = []
-    extends = []
-    includes = []
-
-    found = @stores.map do |store|
-      begin
-        klass = store.load_class name
-        klasses  << klass
-        extends  << [klass.extends,  store] if klass.extends
-        includes << [klass.includes, store] if klass.includes
-        [store, klass]
-      rescue RDoc::Store::MissingFileError
+        @classes
       end
-    end.compact
 
-    extends.reject!  do |modules,| modules.empty? end
-    includes.reject! do |modules,| modules.empty? end
+      ##
+      # Returns the stores wherein +name+ is found along with the classes,
+      # extends and includes that match it
+
+      def classes_and_includes_and_extends_for(name)
+        klasses = []
+        extends = []
+        includes = []
+
+        found = @stores.map do |store|
+          begin
+            klass = store.load_class name
+            klasses  << klass
+            extends  << [klass.extends,  store] if klass.extends
+            includes << [klass.includes, store] if klass.includes
+            [store, klass]
+          rescue ::RDoc::Store::MissingFileError
+          end
+        end.compact
 
-    [found, klasses, includes, extends]
-  end
+        extends.reject!  do |modules,| modules.empty? end
+        includes.reject! do |modules,| modules.empty? end
 
-  ##
-  # Completes +name+ based on the caches.  For Readline
+        [found, klasses, includes, extends]
+      end
 
-  def complete(name)
-    completions = []
+      ##
+      # Completes +name+ based on the caches.  For Readline
 
-    klass, selector, method = parse_name name
+      def complete(name)
+        completions = []
 
-    complete_klass  name, klass, selector, method, completions
-    complete_method name, klass, selector,         completions
+        klass, selector, method = parse_name name
 
-    completions.uniq.select {|s| s.start_with? name }.sort
-  end
+        complete_klass  name, klass, selector, method, completions
+        complete_method name, klass, selector,         completions
 
-  def complete_klass(name, klass, selector, method, completions) # :nodoc:
-    klasses = classes.keys
+        completions.uniq.select {|s| s.start_with? name }.sort
+      end
 
-    # may need to include Foo when given Foo::
-    klass_name = method ? name : klass
+      def complete_klass(name, klass, selector, method, completions) # :nodoc:
+        klasses = classes.keys
 
-    if name !~ /#|\./ then
-      completions.replace klasses.grep(/^#{Regexp.escape klass_name}[^:]*$/)
-      completions.concat klasses.grep(/^#{Regexp.escape name}[^:]*$/) if
-        name =~ /::$/
+        # may need to include Foo when given Foo::
+        klass_name = method ? name : klass
 
-      completions << klass if classes.key? klass # to complete a method name
-    elsif selector then
-      completions << klass if classes.key? klass
-    elsif classes.key? klass_name then
-      completions << klass_name
-    end
-  end
+        if name !~ /#|\./
+          completions.replace klasses.grep(/^#{Regexp.escape klass_name}[^:]*$/)
+          completions.concat klasses.grep(/^#{Regexp.escape name}[^:]*$/) if
+            name =~ /::$/
 
-  def complete_method(name, klass, selector, completions) # :nodoc:
-    if completions.include? klass and name =~ /#|\.|::/ then
-      methods = list_methods_matching name
-
-      if not methods.empty? then
-        # remove Foo if given Foo:: and a method was found
-        completions.delete klass
-      elsif selector then
-        # replace Foo with Foo:: as given
-        completions.delete klass
-        completions << "#{klass}#{selector}"
+          completions << klass if classes.key? klass # to complete a method name
+        elsif selector
+          completions << klass if classes.key? klass
+        elsif classes.key? klass_name
+          completions << klass_name
+        end
       end
 
-      methods.each do |klass_sel_method|
-        match = klass_sel_method.match(/^(.+)(#|\.|::)([^#.:]+)$/)
-        # match[2] is `::` for class method and `#` for instance method.
-        # To be consistent with old completion that completes `['Foo#i', 'Foo::c']` for `Foo.`,
-        # `.` should be a wildcard for both `#` and `::` here.
-        if match && match[2] == selector || selector == '.'
-          completions << match[1] + selector + match[3]
+      def complete_method(name, klass, selector, completions) # :nodoc:
+        if completions.include? klass and name =~ /#|\.|::/
+          methods = list_methods_matching name
+
+          if not methods.empty?
+            # remove Foo if given Foo:: and a method was found
+            completions.delete klass
+          elsif selector
+            # replace Foo with Foo:: as given
+            completions.delete klass
+            completions << "#{klass}#{selector}"
+          end
+
+          methods.each do |klass_sel_method|
+            match = klass_sel_method.match(/^(.+)(#|\.|::)([^#.:]+)$/)
+            # match[2] is `::` for class method and `#` for instance method.
+            # To be consistent with old completion that completes `['Foo#i', 'Foo::c']` for `Foo.`,
+            # `.` should be a wildcard for both `#` and `::` here.
+            if match && match[2] == selector || selector == '.'
+              completions << match[1] + selector + match[3]
+            end
+          end
         end
       end
-    end
-  end
 
-  ##
-  # Converts +document+ to text and writes it to the pager
+      ##
+      # Converts +document+ to text and writes it to the pager
 
-  def display(document)
-    page do |io|
-      f = formatter(io)
-      f.width = @width if @width and f.respond_to?(:width)
-      text = document.accept f
+      def display(document)
+        page do |io|
+          f = formatter(io)
+          f.width = @width if @width and f.respond_to?(:width)
+          text = document.accept f
 
-      io.write text
-    end
-  end
+          io.write text
+        end
+      end
 
-  ##
-  # Outputs formatted RI data for class +name+.  Groups undocumented classes
+      ##
+      # Outputs formatted RI data for class +name+.  Groups undocumented classes
 
-  def display_class(name)
-    return if name =~ /#|\./
+      def display_class(name)
+        _klass, selector, _method = parse_name name
+        return if selector
 
-    found, klasses, includes, extends =
-      classes_and_includes_and_extends_for name
+        found, klasses, includes, extends =
+          classes_and_includes_and_extends_for name
 
-    return if found.empty?
+        return if found.empty?
 
-    out = class_document name, found, klasses, includes, extends
+        out = class_document name, found, klasses, includes, extends
 
-    display out
-  end
+        display out
+      end
 
-  ##
-  # Outputs formatted RI data for method +name+
+      ##
+      # Outputs formatted RI data for method +name+
 
-  def display_method(name)
-    out = RDoc::Markup::Document.new
+      def display_method(name)
+        out = Markup::Document.new
 
-    add_method out, name
+        add_method out, name
 
-    expand_rdoc_refs_at_the_bottom(out)
+        expand_rdoc_refs_at_the_bottom(out)
 
-    display out
-  end
+        display out
+      end
 
-  ##
-  # Outputs formatted RI data for the class or method +name+.
-  #
-  # Returns true if +name+ was found, false if it was not an alternative could
-  # be guessed, raises an error if +name+ couldn't be guessed.
+      ##
+      # Outputs formatted RI data for the class or method +name+.
+      #
+      # Returns true if +name+ was found, false if it was not an alternative could
+      # be guessed, raises an error if +name+ couldn't be guessed.
 
-  def display_name(name)
-    if name =~ /\w:(\w|$)/ then
-      display_page name
-      return true
-    end
+      def display_name(name)
+        if name =~ /\w:(\w|$)/
+          display_page name
+          return true
+        end
 
-    return true if display_class name
+        return true if display_class name
 
-    display_method name if name =~ /::|#|\./
+        display_method name if name =~ /::|#|\./
 
-    true
-  rescue NotFoundError
-    matches = list_methods_matching name if name =~ /::|#|\./
-    matches = classes.keys.grep(/^#{Regexp.escape name}/) if matches.empty?
+        true
+      rescue NotFoundError
+        matches = list_methods_matching name if name =~ /::|#|\./
+        matches = classes.keys.grep(/^#{Regexp.escape name}/) if matches.empty?
 
-    raise if matches.empty?
+        raise if matches.empty?
 
-    page do |io|
-      io.puts "#{name} not found, maybe you meant:"
-      io.puts
-      io.puts matches.sort.join("\n")
-    end
+        page do |io|
+          io.puts "#{name} not found, maybe you meant:"
+          io.puts
+          io.puts matches.sort.join("\n")
+        end
 
-    false
-  end
+        false
+      end
 
-  ##
-  # Displays each name in +name+
+      ##
+      # Displays each name in +name+
 
-  def display_names(names)
-    names.each do |name|
-      name = expand_name name
+      def display_names(names)
+        names.each do |name|
+          name = expand_name name
 
-      display_name name
-    end
-  end
+          display_name name
+        end
+      end
 
-  ##
-  # Outputs formatted RI data for page +name+.
+      ##
+      # Outputs formatted RI data for page +name+.
 
-  def display_page(name)
-    store_name, page_name = name.split ':', 2
+      def display_page(name)
+        store_name, page_name = name.split ':', 2
 
-    store = @stores.find { |s| s.source == store_name }
+        store = @stores.find { |s| s.source == store_name }
 
-    return display_page_list store if page_name.empty?
+        return display_page_list store if page_name.empty?
 
-    pages = store.cache[:pages]
+        pages = store.cache[:pages]
 
-    unless pages.include? page_name then
-      found_names = pages.select do |n|
-        n =~ /#{Regexp.escape page_name}\.[^.]+$/
-      end
+        unless pages.include? page_name
+          found_names = pages.select do |n|
+            n =~ /#{Regexp.escape page_name}\.[^.]+$/
+          end
 
-      if found_names.length.zero? then
-        return display_page_list store, pages
-      elsif found_names.length > 1 then
-        return display_page_list store, found_names, page_name
-      end
+          if found_names.length.zero?
+            return display_page_list store, pages
+          elsif found_names.length > 1
+            return display_page_list store, found_names, page_name
+          end
 
-      page_name = found_names.first
-    end
+          page_name = found_names.first
+        end
 
-    page = store.load_page page_name
+        page = store.load_page page_name
 
-    display page.comment.parse
-  end
+        display page.comment.parse
+      end
 
-  ##
-  # Outputs a formatted RI page list for the pages in +store+.
+      ##
+      # Outputs a formatted RI page list for the pages in +store+.
 
-  def display_page_list(store, pages = store.cache[:pages], search = nil)
-    out = RDoc::Markup::Document.new
+      def display_page_list(store, pages = store.cache[:pages], search = nil)
+        out = Markup::Document.new
 
-    title = if search then
-              "#{search} pages"
-            else
-              'Pages'
-            end
+        title = if search
+                  "#{search} pages"
+                else
+                  'Pages'
+                end
 
-    out << RDoc::Markup::Heading.new(1, "#{title} in #{store.friendly_path}")
-    out << RDoc::Markup::BlankLine.new
+        out << Markup::Heading.new(1, "#{title} in #{store.friendly_path}")
+        out << Markup::BlankLine.new
 
-    list = RDoc::Markup::List.new(:BULLET)
+        list = Markup::List.new(:BULLET)
 
-    pages.each do |page|
-      list << RDoc::Markup::Paragraph.new(page)
-    end
+        pages.each do |page|
+          list << Markup::Paragraph.new(page)
+        end
 
-    out << list
+        out << list
 
-    display out
-  end
+        display out
+      end
 
-  def check_did_you_mean # :nodoc:
-    if defined? DidYouMean::SpellChecker
-      true
-    else
-      begin
-        require 'did_you_mean'
+      def check_did_you_mean # :nodoc:
         if defined? DidYouMean::SpellChecker
           true
         else
-          false
+          begin
+            require 'did_you_mean'
+            if defined? DidYouMean::SpellChecker
+              true
+            else
+              false
+            end
+          rescue LoadError
+            false
+          end
         end
-      rescue LoadError
-        false
       end
-    end
-  end
 
-  ##
-  # Expands abbreviated klass +klass+ into a fully-qualified class.  "Zl::Da"
-  # will be expanded to Zlib::DataError.
-
-  def expand_class(klass)
-    class_names = classes.keys
-    ary = class_names.grep(Regexp.new("\\A#{klass.gsub(/(?=::|\z)/, '[^:]*')}\\z"))
-    if ary.length != 1 && ary.first != klass
-      if check_did_you_mean
-        suggestion_proc = -> { DidYouMean::SpellChecker.new(dictionary: class_names).correct(klass) }
-        raise NotFoundError.new(klass, suggestion_proc)
-      else
-        raise NotFoundError, klass
+      ##
+      # Expands abbreviated klass +klass+ into a fully-qualified class.  "Zl::Da"
+      # will be expanded to Zlib::DataError.
+
+      def expand_class(klass)
+        class_names = classes.keys
+        ary = class_names.grep(Regexp.new("\\A#{klass.gsub(/(?=::|\z)/, '[^:]*')}\\z"))
+        if ary.length != 1 && ary.first != klass
+          if check_did_you_mean
+            suggestion_proc = -> { DidYouMean::SpellChecker.new(dictionary: class_names).correct(klass) }
+            raise NotFoundError.new(klass, suggestion_proc)
+          else
+            raise NotFoundError, klass
+          end
+        end
+        ary.first
       end
-    end
-    ary.first
-  end
 
-  ##
-  # Expands the class portion of +name+ into a fully-qualified class.  See
-  # #expand_class.
+      ##
+      # Expands the class portion of +name+ into a fully-qualified class.  See
+      # #expand_class.
 
-  def expand_name(name)
-    klass, selector, method = parse_name name
+      def expand_name(name)
+        klass, selector, method = parse_name name
 
-    return [selector, method].join if klass.empty?
+        return [selector, method].join if klass.empty?
 
-    case selector
-    when ':' then
-      [find_store(klass),   selector, method]
-    else
-      [expand_class(klass), selector, method]
-    end.join
-  end
+        case selector
+        when ':'
+          [find_store(klass),   selector, method]
+        else
+          [expand_class(klass), selector, method]
+        end.join
+      end
 
-  ##
-  # Filters the methods in +found+ trying to find a match for +name+.
+      ##
+      # Filters the methods in +found+ trying to find a match for +name+.
 
-  def filter_methods(found, name)
-    regexp = name_regexp name
+      def filter_methods(found, name)
+        regexp = name_regexp name
 
-    filtered = found.find_all do |store, methods|
-      methods.any? { |method| method.full_name =~ regexp }
-    end
+        filtered = found.find_all do |store, methods|
+          methods.any? { |method| method.full_name =~ regexp }
+        end
 
-    return filtered unless filtered.empty?
+        return filtered unless filtered.empty?
 
-    found
-  end
+        found
+      end
 
-  ##
-  # Yields items matching +name+ including the store they were found in, the
-  # class being searched for, the class they were found in (an ancestor) the
-  # types of methods to look up (from #method_type), and the method name being
-  # searched for
+      ##
+      # Yields items matching +name+ including the store they were found in, the
+      # class being searched for, the class they were found in (an ancestor) the
+      # types of methods to look up (from #method_type), and the method name being
+      # searched for
 
-  def find_methods(name)
-    klass, selector, method = parse_name name
+      def find_methods(name)
+        klass, selector, method = parse_name name
 
-    types = method_type selector
+        types = method_type selector
 
-    klasses = nil
-    ambiguous = klass.empty?
+        klasses = nil
+        ambiguous = klass.empty?
 
-    if ambiguous then
-      klasses = classes.keys
-    else
-      klasses = ancestors_of klass
-      klasses.unshift klass
-    end
+        if ambiguous
+          klasses = classes.keys
+        else
+          klasses = ancestors_of klass
+          klasses.unshift klass
+        end
 
-    methods = []
+        methods = []
 
-    klasses.each do |ancestor|
-      ancestors = classes[ancestor]
+        klasses.each do |ancestor|
+          ancestors = classes[ancestor]
 
-      next unless ancestors
+          next unless ancestors
 
-      klass = ancestor if ambiguous
+          klass = ancestor if ambiguous
 
-      ancestors.each do |store|
-        methods << [store, klass, ancestor, types, method]
-      end
-    end
+          ancestors.each do |store|
+            methods << [store, klass, ancestor, types, method]
+          end
+        end
 
-    methods = methods.sort_by do |_, k, a, _, m|
-      [k, a, m].compact
-    end
+        methods = methods.sort_by do |_, k, a, _, m|
+          [k, a, m].compact
+        end
 
-    methods.each do |item|
-      yield(*item) # :yields: store, klass, ancestor, types, method
-    end
+        methods.each do |item|
+          yield(*item) # :yields: store, klass, ancestor, types, method
+        end
 
-    self
-  end
+        self
+      end
 
-  ##
-  # Finds a store that matches +name+ which can be the name of a gem, "ruby",
-  # "home" or "site".
-  #
-  # See also RDoc::Store#source
+      ##
+      # Finds a store that matches +name+ which can be the name of a gem, "ruby",
+      # "home" or "site".
+      #
+      # See also RDoc::Store#source
 
-  def find_store(name)
-    @stores.each do |store|
-      source = store.source
+      def find_store(name)
+        @stores.each do |store|
+          source = store.source
 
-      return source if source == name
+          return source if source == name
 
-      return source if
-        store.type == :gem and source =~ /^#{Regexp.escape name}-\d/
-    end
+          return source if
+            store.type == :gem and source =~ /^#{Regexp.escape name}-\d/
+        end
 
-    raise RDoc::RI::Driver::NotFoundError, name
-  end
+        raise RI::Driver::NotFoundError, name
+      end
 
-  ##
-  # Creates a new RDoc::Markup::Formatter.  If a formatter is given with -f,
-  # use it.  If we're outputting to a pager, use bs, otherwise ansi.
-
-  def formatter(io)
-    if @formatter_klass then
-      @formatter_klass.new
-    elsif paging? or !io.tty? then
-      RDoc::Markup::ToBs.new
-    else
-      RDoc::Markup::ToAnsi.new
-    end
-  end
+      ##
+      # Creates a new RDoc::Markup::Formatter.  If a formatter is given with -f,
+      # use it.  If we're outputting to a pager, use bs, otherwise ansi.
 
-  ##
-  # Runs ri interactively using Readline if it is available.
+      def formatter(io)
+        if @formatter_klass
+          @formatter_klass.new
+        elsif paging? or !io.tty?
+          Markup::ToBs.new
+        else
+          Markup::ToAnsi.new
+        end
+      end
 
-  def interactive
-    puts "\nEnter the method name you want to look up."
+      ##
+      # Runs ri interactively using Readline if it is available.
 
-    begin
-      require 'readline'
-    rescue LoadError
-    end
-    if defined? Readline then
-      Readline.completion_proc = method :complete
-      puts "You can use tab to autocomplete."
-    end
+      def interactive
+        puts "\nEnter the method name you want to look up."
+
+        begin
+          require 'readline'
+        rescue LoadError
+        end
+        if defined? Readline
+          Readline.completion_proc = method :complete
+          puts "You can use tab to autocomplete."
+        end
 
-    puts "Enter a blank line to exit.\n\n"
+        puts "Enter a blank line to exit.\n\n"
 
-    loop do
-      name = if defined? Readline then
-               Readline.readline ">> ", true
-             else
-               print ">> "
-               $stdin.gets
-             end
+        loop do
+          name = if defined? Readline
+                   Readline.readline ">> ", true
+                 else
+                   print ">> "
+                   $stdin.gets
+                 end
 
-      return if name.nil? or name.empty?
+          return if name.nil? or name.empty?
 
-      begin
-        display_name expand_name(name.strip)
-      rescue NotFoundError => e
-        puts e.message
+          begin
+            display_name expand_name(name.strip)
+          rescue NotFoundError => e
+            puts e.message
+          end
+        end
+
+      rescue Interrupt
+        exit
       end
-    end
 
-  rescue Interrupt
-    exit
-  end
+      ##
+      # Lists classes known to ri starting with +names+.  If +names+ is empty all
+      # known classes are shown.
 
-  ##
-  # Lists classes known to ri starting with +names+.  If +names+ is empty all
-  # known classes are shown.
+      def list_known_classes(names = [])
+        classes = []
 
-  def list_known_classes(names = [])
-    classes = []
+        stores.each do |store|
+          classes << store.module_names
+        end
 
-    stores.each do |store|
-      classes << store.module_names
-    end
+        classes = classes.flatten.uniq.sort
 
-    classes = classes.flatten.uniq.sort
+        unless names.empty?
+          filter = Regexp.union names.map { |name| /^#{name}/ }
 
-    unless names.empty? then
-      filter = Regexp.union names.map { |name| /^#{name}/ }
+          classes = classes.grep filter
+        end
 
-      classes = classes.grep filter
-    end
+        page do |io|
+          if paging? or io.tty?
+            if names.empty?
+              io.puts "Classes and Modules known to ri:"
+            else
+              io.puts "Classes and Modules starting with #{names.join ', '}:"
+            end
+            io.puts
+          end
 
-    page do |io|
-      if paging? or io.tty? then
-        if names.empty? then
-          io.puts "Classes and Modules known to ri:"
-        else
-          io.puts "Classes and Modules starting with #{names.join ', '}:"
+          io.puts classes.join("\n")
         end
-        io.puts
       end
 
-      io.puts classes.join("\n")
-    end
-  end
+      ##
+      # Returns an Array of methods matching +name+
 
-  ##
-  # Returns an Array of methods matching +name+
+      def list_methods_matching(name)
+        found = []
 
-  def list_methods_matching(name)
-    found = []
+        find_methods name do |store, klass, ancestor, types, method|
+          if types == :instance or types == :both
+            methods = store.instance_methods[ancestor]
 
-    find_methods name do |store, klass, ancestor, types, method|
-      if types == :instance or types == :both then
-        methods = store.instance_methods[ancestor]
+            if methods
+              matches = methods.grep(/^#{Regexp.escape method.to_s}/)
 
-        if methods then
-          matches = methods.grep(/^#{Regexp.escape method.to_s}/)
+              matches = matches.map do |match|
+                "#{klass}##{match}"
+              end
 
-          matches = matches.map do |match|
-            "#{klass}##{match}"
+              found.concat matches
+            end
           end
 
-          found.concat matches
-        end
-      end
+          if types == :class or types == :both
+            methods = store.class_methods[ancestor]
 
-      if types == :class or types == :both then
-        methods = store.class_methods[ancestor]
+            next unless methods
+            matches = methods.grep(/^#{Regexp.escape method.to_s}/)
 
-        next unless methods
-        matches = methods.grep(/^#{Regexp.escape method.to_s}/)
+            matches = matches.map do |match|
+              "#{klass}::#{match}"
+            end
 
-        matches = matches.map do |match|
-          "#{klass}::#{match}"
+            found.concat matches
+          end
         end
 
-        found.concat matches
+        found.uniq
       end
-    end
-
-    found.uniq
-  end
 
-  ##
-  # Loads RI data for method +name+ on +klass+ from +store+.  +type+ and
-  # +cache+ indicate if it is a class or instance method.
+      ##
+      # Loads RI data for method +name+ on +klass+ from +store+.  +type+ and
+      # +cache+ indicate if it is a class or instance method.
 
-  def load_method(store, cache, klass, type, name)
-    methods = store.public_send(cache)[klass]
+      def load_method(store, cache, klass, type, name)
+        methods = store.public_send(cache)[klass]
 
-    return unless methods
+        return unless methods
 
-    method = methods.find do |method_name|
-      method_name == name
-    end
+        method = methods.find do |method_name|
+          method_name == name
+        end
 
-    return unless method
+        return unless method
 
-    store.load_method klass, "#{type}#{method}"
-  rescue RDoc::Store::MissingFileError => e
-    comment = RDoc::Comment.new("missing documentation at #{e.file}")
-    comment.parse
+        store.load_method klass, "#{type}#{method}"
+      rescue ::RDoc::Store::MissingFileError => e
+        comment = Comment.new("missing documentation at #{e.file}")
+        comment.parse
 
-    method = RDoc::AnyMethod.new name
-    method.comment = comment
-    method
-  end
+        method = AnyMethod.new name
+        method.comment = comment
+        method
+      end
 
-  ##
-  # Returns an Array of RI data for methods matching +name+
+      ##
+      # Returns an Array of RI data for methods matching +name+
 
-  def load_methods_matching(name)
-    found = []
+      def load_methods_matching(name)
+        found = []
 
-    find_methods name do |store, klass, ancestor, types, method|
-      methods = []
+        find_methods name do |store, klass, ancestor, types, method|
+          methods = []
 
-      methods << load_method(store, :class_methods, ancestor, '::',  method) if
-        [:class, :both].include? types
+          methods << load_method(store, :class_methods, ancestor, '::',  method) if
+            [:class, :both].include? types
 
-      methods << load_method(store, :instance_methods, ancestor, '#',  method) if
-        [:instance, :both].include? types
+          methods << load_method(store, :instance_methods, ancestor, '#',  method) if
+            [:instance, :both].include? types
 
-      found << [store, methods.compact]
-    end
+          found << [store, methods.compact]
+        end
 
-    found.reject do |path, methods| methods.empty? end
-  end
+        found.reject do |path, methods| methods.empty? end
+      end
 
-  ##
-  # Returns a filtered list of methods matching +name+
+      ##
+      # Returns a filtered list of methods matching +name+
 
-  def lookup_method(name)
-    found = load_methods_matching name
+      def lookup_method(name)
+        found = load_methods_matching name
 
-    if found.empty?
-      if check_did_you_mean
-        methods = []
-        _, _, method_name = parse_name name
-        find_methods name do |store, klass, ancestor, types, method|
-          methods.push(*store.class_methods[klass]) if [:class, :both].include? types
-          methods.push(*store.instance_methods[klass]) if [:instance, :both].include? types
+        if found.empty?
+          if check_did_you_mean
+            methods = []
+            _, _, method_name = parse_name name
+            find_methods name do |store, klass, ancestor, types, method|
+              methods.push(*store.class_methods[klass]) if [:class, :both].include? types
+              methods.push(*store.instance_methods[klass]) if [:instance, :both].include? types
+            end
+            methods = methods.uniq
+            suggestion_proc = -> { DidYouMean::SpellChecker.new(dictionary: methods).correct(method_name) }
+            raise NotFoundError.new(name, suggestion_proc)
+          else
+            raise NotFoundError, name
+          end
         end
-        methods = methods.uniq
-        suggestion_proc = -> { DidYouMean::SpellChecker.new(dictionary: methods).correct(method_name) }
-        raise NotFoundError.new(name, suggestion_proc)
-      else
-        raise NotFoundError, name
+
+        filter_methods found, name
       end
-    end
 
-    filter_methods found, name
-  end
+      ##
+      # Builds a RDoc::Markup::Document from +found+, +klasses+ and +includes+
 
-  ##
-  # Builds a RDoc::Markup::Document from +found+, +klasses+ and +includes+
+      def method_document(out, name, filtered)
+        out << Markup::Heading.new(1, name)
+        out << Markup::BlankLine.new
 
-  def method_document(out, name, filtered)
-    out << RDoc::Markup::Heading.new(1, name)
-    out << RDoc::Markup::BlankLine.new
+        filtered.each do |store, methods|
+          methods.each do |method|
+            render_method out, store, method, name
+          end
+        end
 
-    filtered.each do |store, methods|
-      methods.each do |method|
-        render_method out, store, method, name
+        out
       end
-    end
 
-    out
-  end
-
-  ##
-  # Returns the type of method (:both, :instance, :class) for +selector+
+      ##
+      # Returns the type of method (:both, :instance, :class) for +selector+
 
-  def method_type(selector)
-    case selector
-    when '.', nil then :both
-    when '#'      then :instance
-    else               :class
-    end
-  end
+      def method_type(selector)
+        case selector
+        when '.', nil then :both
+        when '#'      then :instance
+        else               :class
+        end
+      end
 
-  ##
-  # Returns a regular expression for +name+ that will match an
-  # RDoc::AnyMethod's name.
+      ##
+      # Returns a regular expression for +name+ that will match an
+      # RDoc::AnyMethod's name.
 
-  def name_regexp(name)
-    klass, type, name = parse_name name
+      def name_regexp(name)
+        klass, type, name = parse_name name
 
-    case type
-    when '#', '::' then
-      /^#{klass}#{type}#{Regexp.escape name}$/
-    else
-      /^#{klass}(#|::)#{Regexp.escape name}$/
-    end
-  end
+        case type
+        when '#', '::'
+          /^#{klass}#{type}#{Regexp.escape name}$/
+        else
+          /^#{klass}(#|::)#{Regexp.escape name}$/
+        end
+      end
 
-  ##
-  # Paginates output through a pager program.
+      ##
+      # Paginates output through a pager program.
 
-  def page
-    if pager = setup_pager then
-      begin
-        yield pager
+      def page
+        if pager = setup_pager
+          begin
+            yield pager
+          ensure
+            pager.close
+          end
+        else
+          yield $stdout
+        end
+      rescue Errno::EPIPE
       ensure
-        pager.close
+        @paging = false
       end
-    else
-      yield $stdout
-    end
-  rescue Errno::EPIPE
-  ensure
-    @paging = false
-  end
 
-  ##
-  # Are we using a pager?
+      ##
+      # Are we using a pager?
 
-  def paging?
-    @paging
-  end
+      def paging?
+        @paging
+      end
+
+      ##
+      # Extracts the class, selector and method name parts from +name+ like
+      # Foo::Bar#baz.
+      #
+      # NOTE: Given Foo::Bar, Bar is considered a class even though it may be a
+      # method
+
+      def parse_name(name)
+        parts = name.split(/(::?|#|\.)/)
+
+        if parts.length == 1
+          if parts.first =~ /^[a-z]|^([%&*+\/<>^`|~-]|\+@|-@|<<|<=>?|===?|=>|=~|>>|\[\]=?|~@)$/
+            type = '.'
+            meth = parts.pop
+          else
+            type = nil
+            meth = nil
+          end
+        elsif parts.length == 2 or parts.last =~ /::|#|\./
+          type = parts.pop
+          meth = nil
+        elsif parts[1] == ':'
+          klass = parts.shift
+          type  = parts.shift
+          meth  = parts.join
+        elsif parts[-2] != '::' or parts.last !~ /^[A-Z]/
+          meth = parts.pop
+          type = parts.pop
+        end
+
+        klass ||= parts.join
 
-  ##
-  # Extracts the class, selector and method name parts from +name+ like
-  # Foo::Bar#baz.
-  #
-  # NOTE: Given Foo::Bar, Bar is considered a class even though it may be a
-  # method
-
-  def parse_name(name)
-    parts = name.split(/(::?|#|\.)/)
-
-    if parts.length == 1 then
-      if parts.first =~ /^[a-z]|^([%&*+\/<>^`|~-]|\+@|-@|<<|<=>?|===?|=>|=~|>>|\[\]=?|~@)$/ then
-        type = '.'
-        meth = parts.pop
-      else
-        type = nil
-        meth = nil
+        [klass, type, meth]
       end
-    elsif parts.length == 2 or parts.last =~ /::|#|\./ then
-      type = parts.pop
-      meth = nil
-    elsif parts[1] == ':' then
-      klass = parts.shift
-      type  = parts.shift
-      meth  = parts.join
-    elsif parts[-2] != '::' or parts.last !~ /^[A-Z]/ then
-      meth = parts.pop
-      type = parts.pop
-    end
 
-    klass ||= parts.join
+      ##
+      # Renders the +klass+ from +store+ to +out+.  If the klass has no
+      # documentable items the class is added to +also_in+ instead.
+
+      def render_class(out, store, klass, also_in) # :nodoc:
+        document = klass.comment.parse
+        # TODO the store's cache should always return an empty Array
+        class_methods    = store.class_methods[klass.full_name]    || []
+        instance_methods = store.instance_methods[klass.full_name] || []
+        attributes       = store.attributes[klass.full_name]       || []
+
+        if document.empty? and
+           instance_methods.empty? and class_methods.empty?
+          also_in << store
+          return
+        end
 
-    [klass, type, meth]
-  end
+        add_from out, store
 
-  ##
-  # Renders the +klass+ from +store+ to +out+.  If the klass has no
-  # documentable items the class is added to +also_in+ instead.
-
-  def render_class(out, store, klass, also_in) # :nodoc:
-    document = klass.comment.parse
-    # TODO the store's cache should always return an empty Array
-    class_methods    = store.class_methods[klass.full_name]    || []
-    instance_methods = store.instance_methods[klass.full_name] || []
-    attributes       = store.attributes[klass.full_name]       || []
-
-    if document.empty? and
-       instance_methods.empty? and class_methods.empty? then
-      also_in << store
-      return
-    end
+        class_document_comment out, document
 
-    add_from out, store
+        if class_methods or instance_methods or not klass.constants.empty?
+          out << Markup::Rule.new(1)
+        end
 
-    class_document_comment out, document
+        class_document_constants out, klass
 
-    if class_methods or instance_methods or not klass.constants.empty? then
-      out << RDoc::Markup::Rule.new(1)
-    end
+        add_method_list out, class_methods,    'Class methods'
+        add_method_list out, instance_methods, 'Instance methods'
+        add_method_list out, attributes,       'Attributes'
 
-    class_document_constants out, klass
+        add_method_documentation out, klass if @show_all
+      end
 
-    add_method_list out, class_methods,    'Class methods'
-    add_method_list out, instance_methods, 'Instance methods'
-    add_method_list out, attributes,       'Attributes'
+      def render_method(out, store, method, name) # :nodoc:
+        out << Markup::Paragraph.new("(from #{store.friendly_path})")
 
-    add_method_documentation out, klass if @show_all
-  end
+        unless name =~ /^#{Regexp.escape method.parent_name}/
+          out << Markup::Heading.new(3, "Implementation from #{method.parent_name}")
+        end
 
-  def render_method(out, store, method, name) # :nodoc:
-    out << RDoc::Markup::Paragraph.new("(from #{store.friendly_path})")
+        out << Markup::Rule.new(1)
 
-    unless name =~ /^#{Regexp.escape method.parent_name}/ then
-      out << RDoc::Markup::Heading.new(3, "Implementation from #{method.parent_name}")
-    end
+        render_method_arguments out, method.arglists
+        sig = method.type_signature_lines || store.rbs_signature_for(method)
+        render_method_type_signature out, sig if sig
+        render_method_superclass out, method
+        if method.is_alias_for
+          al = method.is_alias_for
+          alias_for = store.load_method al.parent_name, "#{al.name_prefix}#{al.name}"
+          render_method_comment out, method, alias_for
+        else
+          render_method_comment out, method
+        end
+      end
 
-    out << RDoc::Markup::Rule.new(1)
-
-    render_method_arguments out, method.arglists
-    sig = method.type_signature_lines || store.rbs_signature_for(method)
-    render_method_type_signature out, sig if sig
-    render_method_superclass out, method
-    if method.is_alias_for
-      al = method.is_alias_for
-      alias_for = store.load_method al.parent_name, "#{al.name_prefix}#{al.name}"
-      render_method_comment out, method, alias_for
-    else
-      render_method_comment out, method
-    end
-  end
+      def render_method_arguments(out, arglists) # :nodoc:
+        return unless arglists
 
-  def render_method_arguments(out, arglists) # :nodoc:
-    return unless arglists
+        arglists = arglists.chomp.split "\n"
+        arglists = arglists.map { |line| line + "\n" }
+        out << Markup::Verbatim.new(*arglists)
+        out << Markup::Rule.new(1)
+      end
 
-    arglists = arglists.chomp.split "\n"
-    arglists = arglists.map { |line| line + "\n" }
-    out << RDoc::Markup::Verbatim.new(*arglists)
-    out << RDoc::Markup::Rule.new(1)
-  end
+      def render_method_comment(out, method, alias_for = nil)# :nodoc:
+        if alias_for
+          unless method.comment.nil? or method.comment.empty?
+            out << Markup::BlankLine.new
+            out << method.comment.parse
+          end
+          out << Markup::BlankLine.new
+          out << Markup::Paragraph.new("(This method is an alias for #{alias_for.full_name}.)")
+          out << Markup::BlankLine.new
+          out << alias_for.comment.parse
+          out << Markup::BlankLine.new
+        else
+          out << Markup::BlankLine.new
+          out << method.comment.parse
+          out << Markup::BlankLine.new
+        end
+      end
 
-  def render_method_comment(out, method, alias_for = nil)# :nodoc:
-    if alias_for
-      unless method.comment.nil? or method.comment.empty?
-        out << RDoc::Markup::BlankLine.new
-        out << method.comment.parse
+      def render_method_type_signature(out, lines) # :nodoc:
+        out << Markup::Verbatim.new(*lines.map { |s| s + "\n" })
       end
-      out << RDoc::Markup::BlankLine.new
-      out << RDoc::Markup::Paragraph.new("(This method is an alias for #{alias_for.full_name}.)")
-      out << RDoc::Markup::BlankLine.new
-      out << alias_for.comment.parse
-      out << RDoc::Markup::BlankLine.new
-    else
-      out << RDoc::Markup::BlankLine.new
-      out << method.comment.parse
-      out << RDoc::Markup::BlankLine.new
-    end
-  end
 
-  def render_method_type_signature(out, lines) # :nodoc:
-    out << RDoc::Markup::Verbatim.new(*lines.map { |s| s + "\n" })
-  end
+      def render_method_superclass(out, method) # :nodoc:
+        return unless
+          method.respond_to?(:superclass_method) and method.superclass_method
 
-  def render_method_superclass(out, method) # :nodoc:
-    return unless
-      method.respond_to?(:superclass_method) and method.superclass_method
+        out << Markup::BlankLine.new
+        out << Markup::Heading.new(4, "(Uses superclass method #{method.superclass_method})")
+        out << Markup::Rule.new(1)
+      end
 
-    out << RDoc::Markup::BlankLine.new
-    out << RDoc::Markup::Heading.new(4, "(Uses superclass method #{method.superclass_method})")
-    out << RDoc::Markup::Rule.new(1)
-  end
+      ##
+      # Looks up and displays ri data according to the options given.
+
+      def run
+        if @list_doc_dirs
+          puts @doc_dirs
+        elsif @list
+          list_known_classes @names
+        elsif @server
+          start_server
+        elsif @interactive or @names.empty?
+          interactive
+        else
+          display_names @names
+        end
+      rescue NotFoundError => e
+        abort e.message
+      end
 
-  ##
-  # Looks up and displays ri data according to the options given.
-
-  def run
-    if @list_doc_dirs then
-      puts @doc_dirs
-    elsif @list then
-      list_known_classes @names
-    elsif @server then
-      start_server
-    elsif @interactive or @names.empty? then
-      interactive
-    else
-      display_names @names
-    end
-  rescue NotFoundError => e
-    abort e.message
-  end
+      ##
+      # Sets up a pager program to pass output through.  Tries the RI_PAGER and
+      # PAGER environment variables followed by pager, less then more.
 
-  ##
-  # Sets up a pager program to pass output through.  Tries the RI_PAGER and
-  # PAGER environment variables followed by pager, less then more.
+      def setup_pager
+        return if @use_stdout
 
-  def setup_pager
-    return if @use_stdout
+        pagers = [ENV['RI_PAGER'], ENV['PAGER'], 'pager', 'less', 'more']
 
-    pagers = [ENV['RI_PAGER'], ENV['PAGER'], 'pager', 'less', 'more']
+        require 'shellwords'
+        pagers.compact.uniq.each do |pager|
+          pager = Shellwords.split(pager)
+          next if pager.empty?
 
-    require 'shellwords'
-    pagers.compact.uniq.each do |pager|
-      pager = Shellwords.split(pager)
-      next if pager.empty?
+          io = IO.popen(pager, 'w') rescue next
+          next if $? and $?.pid == io.pid and $?.exited? # pager didn't work
 
-      io = IO.popen(pager, 'w') rescue next
-      next if $? and $?.pid == io.pid and $?.exited? # pager didn't work
+          @paging = true
 
-      @paging = true
+          return io
+        end
 
-      return io
-    end
+        @use_stdout = true
 
-    @use_stdout = true
+        nil
+      end
 
-    nil
-  end
+      ##
+      # Starts a WEBrick server for ri.
 
-  ##
-  # Starts a WEBrick server for ri.
+      def start_server
+        begin
+          require 'webrick'
+        rescue LoadError
+          abort "webrick is not found. You may need to `gem install webrick` to install webrick."
+        end
 
-  def start_server
-    begin
-      require 'webrick'
-    rescue LoadError
-      abort "webrick is not found. You may need to `gem install webrick` to install webrick."
-    end
+        server = WEBrick::HTTPServer.new :Port => @server
 
-    server = WEBrick::HTTPServer.new :Port => @server
+        extra_doc_dirs = @stores.map {|s| s.type == :extra ? s.path : nil}.compact
 
-    extra_doc_dirs = @stores.map {|s| s.type == :extra ? s.path : nil}.compact
+        server.mount '/', RI::Servlet, nil, extra_doc_dirs
 
-    server.mount '/', RDoc::RI::Servlet, nil, extra_doc_dirs
+        trap 'INT'  do server.shutdown end
+        trap 'TERM' do server.shutdown end
 
-    trap 'INT'  do server.shutdown end
-    trap 'TERM' do server.shutdown end
+        server.start
+      end
 
-    server.start
-  end
+      RDOC_REFS_REGEXP = /\[rdoc-ref:([\w.]+)(@.*)?\]/
 
-  RDOC_REFS_REGEXP = /\[rdoc-ref:([\w.]+)(@.*)?\]/
+      def expand_rdoc_refs_at_the_bottom(out)
+        return unless @expand_refs
 
-  def expand_rdoc_refs_at_the_bottom(out)
-    return unless @expand_refs
+        extracted_rdoc_refs = []
 
-    extracted_rdoc_refs = []
+        out.each do |part|
+          content = if part.respond_to?(:text)
+                      part.text
+          else
+            next
+          end
 
-    out.each do |part|
-      content = if part.respond_to?(:text)
-        part.text
-      else
-        next
-      end
+          rdoc_refs = content.scan(RDOC_REFS_REGEXP).uniq.map do |file_name, _anchor|
+            file_name
+          end
 
-      rdoc_refs = content.scan(RDOC_REFS_REGEXP).uniq.map do |file_name, _anchor|
-        file_name
-      end
+          extracted_rdoc_refs.concat(rdoc_refs)
+        end
 
-      extracted_rdoc_refs.concat(rdoc_refs)
-    end
+        found_pages = extracted_rdoc_refs.map do |ref|
+          begin
+            @stores.first.load_page(ref)
+          rescue ::RDoc::Store::MissingFileError
+          end
+        end.compact
 
-    found_pages = extracted_rdoc_refs.map do |ref|
-      begin
-        @stores.first.load_page(ref)
-      rescue RDoc::Store::MissingFileError
+        found_pages.each do |page|
+          out << Markup::Heading.new(4, "Expanded from #{page.full_name}")
+          out << Markup::BlankLine.new
+          out << page.comment.parse
+        end
       end
-    end.compact
-
-    found_pages.each do |page|
-      out << RDoc::Markup::Heading.new(4, "Expanded from #{page.full_name}")
-      out << RDoc::Markup::BlankLine.new
-      out << page.comment.parse
     end
   end
 end