rdoc 6.3.4.1 → 8.0.0

data/lib/rdoc/ri/driver.rb

@@ -1,23 +1,10 @@
 # frozen_string_literal: true
-require 'abbrev'
 require 'optparse'
 
-begin
-  require 'readline'
-rescue LoadError
-end
-
-begin
-  require 'win32console'
-rescue LoadError
-end
-
-require 'rdoc'
-
-##
-# For RubyGems backwards compatibility
+require_relative '../../rdoc'
 
-require_relative 'formatter'
+require_relative 'formatter' # For RubyGems backwards compatibility
+# TODO: Fix weird documentation with `require_relative`
 
 ##
 # The RI driver implements the command-line ri tool.
@@ -47,9 +34,9 @@ class RDoc::RI::Driver
 
   class NotFoundError < Error
 
-    def initialize(klass, suggestions = nil) # :nodoc:
+    def initialize(klass, suggestion_proc = nil) # :nodoc:
       @klass = klass
-      @suggestions = suggestions
+      @suggestion_proc = suggestion_proc
     end
 
     ##
@@ -61,8 +48,9 @@ class RDoc::RI::Driver
 
     def message # :nodoc:
       str = "Nothing known about #{@klass}"
-      if @suggestions and !@suggestions.empty?
-        str += "\nDid you mean?  #{@suggestions.join("\n               ")}"
+      suggestions = @suggestion_proc&.call
+      if suggestions and !suggestions.empty?
+        str += "\nDid you mean?  #{suggestions.join("\n               ")}"
       end
       str
     end
@@ -91,6 +79,7 @@ class RDoc::RI::Driver
     options[:interactive] = false
     options[:profile]     = false
     options[:show_all]    = false
+    options[:expand_refs] = true
     options[:use_stdout]  = !$stdout.tty?
     options[:width]       = 72
 
@@ -107,7 +96,7 @@ class RDoc::RI::Driver
   ##
   # Dump +data_path+ using pp
 
-  def self.dump data_path
+  def self.dump(data_path)
     require 'pp'
 
     File.open data_path, 'rb' do |io|
@@ -118,14 +107,10 @@ class RDoc::RI::Driver
   ##
   # Parses +argv+ and returns a Hash of options
 
-  def self.process_args argv
+  def self.process_args(argv)
     options = default_options
 
     opts = OptionParser.new do |opt|
-      opt.accept File do |file,|
-        File.readable?(file) and not File.directory?(file) and file
-      end
-
       opt.program_name = File.basename $0
       opt.version = RDoc::VERSION
       opt.release = nil
@@ -142,6 +127,8 @@ Where name can be:
 
   gem_name: | gem_name:README | gem_name:History
 
+  ruby: | ruby:NEWS | ruby:globals
+
 All class names may be abbreviated to their minimum unambiguous form.
 If a name is ambiguous, all valid options will be listed.
 
@@ -153,6 +140,10 @@ they're contained in.  If the gem name is followed by a ':' all files in the
 gem will be shown.  The file name extension may be omitted where it is
 unambiguous.
 
+'ruby' can be used as a pseudo gem name to display files from the Ruby
+core documentation. Use 'ruby:' by itself to get a list of all available
+core documentation files.
+
 For example:
 
     #{opt.program_name} Fil
@@ -160,6 +151,7 @@ For example:
     #{opt.program_name} File.new
     #{opt.program_name} zip
     #{opt.program_name} rdoc:README
+    #{opt.program_name} ruby:comments
 
 Note that shell quoting or escaping may be required for method names
 containing punctuation:
@@ -254,6 +246,12 @@ or the PAGER environment variable.
 
       opt.separator nil
 
+      opt.on("--[no-]expand-refs", "Expand rdoc-refs at the end of output") do |value|
+        options[:expand_refs] = value
+      end
+
+      opt.separator nil
+
       opt.on("--help", "-h",
              "Show help and exit.") do
         puts opts
@@ -350,9 +348,17 @@ or the PAGER environment variable.
 
       opt.separator nil
 
-      opt.on("--dump=CACHE", File,
+      opt.on("--dump=CACHE",
              "Dump data from an ri cache or data file.") do |value|
-        options[:dump_path] = value
+        unless File.readable?(value)
+          abort "#{value.inspect} is not readable"
+        end
+
+        if File.directory?(value)
+          abort "#{value.inspect} is a directory"
+        end
+
+        options[:dump_path] = File.new(value)
       end
     end
 
@@ -378,7 +384,7 @@ or the PAGER environment variable.
   ##
   # Runs the ri command line executable using +argv+
 
-  def self.run argv = ARGV
+  def self.run(argv = ARGV)
     options = process_args argv
 
     if options[:dump_path] then
@@ -393,7 +399,7 @@ or the PAGER environment variable.
   ##
   # Creates a new driver using +initial_options+ from ::process_args
 
-  def initialize initial_options = {}
+  def initialize(initial_options = {})
     @paging = false
     @classes = nil
 
@@ -414,7 +420,7 @@ or the PAGER environment variable.
                          *options[:extra_doc_dirs]) do |path, type|
       @doc_dirs << path
 
-      store = RDoc::RI::Store.new path, type
+      store = RDoc::RI::Store.new(RDoc::Options.new, path: path, type: type)
       store.load_cache
       @stores << store
     end
@@ -426,15 +432,13 @@ or the PAGER environment variable.
     @use_stdout  = options[:use_stdout]
     @show_all    = options[:show_all]
     @width       = options[:width]
-
-    # pager process for jruby
-    @jruby_pager_process = nil
+    @expand_refs = options[:expand_refs]
   end
 
   ##
   # Adds paths for undocumented classes +also_in+ to +out+
 
-  def add_also_in out, also_in
+  def add_also_in(out, also_in)
     return if also_in.empty?
 
     out << RDoc::Markup::Rule.new(1)
@@ -451,7 +455,7 @@ or the PAGER environment variable.
   # Adds a class header to +out+ for class +name+ which is described in
   # +classes+.
 
-  def add_class out, name, classes
+  def add_class(out, name, classes)
     heading = if classes.all? { |klass| klass.module? } then
                 name
               else
@@ -471,14 +475,14 @@ or the PAGER environment variable.
   ##
   # Adds "(from ...)" to +out+ for +store+
 
-  def add_from out, store
+  def add_from(out, store)
     out << RDoc::Markup::Paragraph.new("(from #{store.friendly_path})")
   end
 
   ##
   # Adds +extends+ to +out+
 
-  def add_extends out, extends
+  def add_extends(out, extends)
     add_extension_modules out, 'Extended by', extends
   end
 
@@ -486,7 +490,7 @@ or the PAGER environment variable.
   # 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
+  def add_extension_modules(out, type, extensions)
     return if extensions.empty?
 
     out << RDoc::Markup::Rule.new(1)
@@ -504,7 +508,7 @@ or the PAGER environment variable.
   ##
   # Renders multiple included +modules+ from +store+ to +out+.
 
-  def add_extension_modules_multiple out, store, modules # :nodoc:
+  def add_extension_modules_multiple(out, store, modules) # :nodoc:
     out << RDoc::Markup::Paragraph.new("(from #{store.friendly_path})")
 
     wout, with = modules.partition { |incl| incl.comment.empty? }
@@ -514,7 +518,7 @@ or the PAGER environment variable.
     with.each do |incl|
       out << RDoc::Markup::Paragraph.new(incl.name)
       out << RDoc::Markup::BlankLine.new
-      out << incl.comment
+      out << incl.comment.parse
     end
 
     unless wout.empty? then
@@ -531,39 +535,36 @@ or the PAGER environment variable.
   ##
   # Adds a single extension module +include+ from +store+ to +out+
 
-  def add_extension_modules_single out, store, include # :nodoc:
+  def add_extension_modules_single(out, store, include) # :nodoc:
     name = include.name
     path = store.friendly_path
     out << RDoc::Markup::Paragraph.new("#{name} (from #{path})")
 
     if include.comment then
       out << RDoc::Markup::BlankLine.new
-      out << include.comment
+      out << include.comment.parse
     end
   end
 
   ##
   # Adds +includes+ to +out+
 
-  def add_includes out, includes
+  def add_includes(out, includes)
     add_extension_modules out, 'Includes', includes
   end
 
   ##
   # Looks up the method +name+ and adds it to +out+
 
-  def add_method out, name
-    filtered   = lookup_method name
-
-    method_out = method_document name, filtered
-
-    out.concat method_out.parts
+  def add_method(out, name)
+    filtered = lookup_method name
+    method_document out, name, filtered
   end
 
   ##
   # Adds documentation for all methods in +klass+ to +out+
 
-  def add_method_documentation out, klass
+  def add_method_documentation(out, klass)
     klass.method_list.each do |method|
       begin
         add_method out, method.full_name
@@ -576,7 +577,7 @@ or the PAGER environment variable.
   ##
   # Adds a list of +methods+ to +out+ with a heading of +name+
 
-  def add_method_list out, methods, name
+  def add_method_list(out, methods, name)
     return if methods.empty?
 
     out << RDoc::Markup::Heading.new(1, "#{name}:")
@@ -596,7 +597,7 @@ or the PAGER environment variable.
   ##
   # Returns ancestor classes of +klass+
 
-  def ancestors_of klass
+  def ancestors_of(klass)
     ancestors = []
 
     unexamined = [klass]
@@ -609,11 +610,11 @@ or the PAGER environment variable.
 
       stores = classes[current]
 
-      break unless stores and not stores.empty?
+      next unless stores and not stores.empty?
 
-      klasses = stores.map do |store|
-        store.ancestors[current]
-      end.flatten.uniq
+      klasses = stores.flat_map do |store|
+        store.ancestors[current] || []
+      end.uniq
 
       klasses = klasses - seen
 
@@ -633,7 +634,7 @@ or the PAGER environment variable.
   ##
   # Builds a RDoc::Markup::Document from +found+, +klasess+ and +includes+
 
-  def class_document name, found, klasses, includes, extends
+  def class_document(name, found, klasses, includes, extends)
     also_in = []
 
     out = RDoc::Markup::Document.new
@@ -649,18 +650,19 @@ or the PAGER environment variable.
 
     add_also_in out, also_in
 
+    expand_rdoc_refs_at_the_bottom(out)
     out
   end
 
   ##
   # Adds the class +comment+ to +out+.
 
-  def class_document_comment out, comment # :nodoc:
-    unless comment.empty? then
+  def class_document_comment(out, document) # :nodoc:
+    unless document.empty? then
       out << RDoc::Markup::Rule.new(1)
 
-      if comment.merged? then
-        parts = comment.parts
+      if document.merged? then
+        parts = document.parts
         parts = parts.zip [RDoc::Markup::BlankLine.new] * parts.length
         parts.flatten!
         parts.pop
@@ -675,7 +677,7 @@ or the PAGER environment variable.
   ##
   # Adds the constants from +klass+ to the Document +out+.
 
-  def class_document_constants out, klass # :nodoc:
+  def class_document_constants(out, klass) # :nodoc:
     return if klass.constants.empty?
 
     out << RDoc::Markup::Heading.new(1, "Constants:")
@@ -685,7 +687,7 @@ or the PAGER environment variable.
     constants = klass.constants.sort_by { |constant| constant.name }
 
     list.items.concat constants.map { |constant|
-      parts = constant.comment.parts if constant.comment
+      parts = constant.comment.parse.parts
       parts << RDoc::Markup::Paragraph.new('[not documented]') if
         parts.empty?
 
@@ -719,7 +721,7 @@ or the PAGER environment variable.
   # 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
+  def classes_and_includes_and_extends_for(name)
     klasses = []
     extends = []
     includes = []
@@ -744,7 +746,7 @@ or the PAGER environment variable.
   ##
   # Completes +name+ based on the caches.  For Readline
 
-  def complete name
+  def complete(name)
     completions = []
 
     klass, selector, method = parse_name name
@@ -752,10 +754,10 @@ or the PAGER environment variable.
     complete_klass  name, klass, selector, method, completions
     complete_method name, klass, selector,         completions
 
-    completions.sort.uniq
+    completions.uniq.select {|s| s.start_with? name }.sort
   end
 
-  def complete_klass name, klass, selector, method, completions # :nodoc:
+  def complete_klass(name, klass, selector, method, completions) # :nodoc:
     klasses = classes.keys
 
     # may need to include Foo when given Foo::
@@ -774,7 +776,7 @@ or the PAGER environment variable.
     end
   end
 
-  def complete_method name, klass, selector, completions # :nodoc:
+  def complete_method(name, klass, selector, completions) # :nodoc:
     if completions.include? klass and name =~ /#|\.|::/ then
       methods = list_methods_matching name
 
@@ -787,14 +789,22 @@ or the PAGER environment variable.
         completions << "#{klass}#{selector}"
       end
 
-      completions.concat methods
+      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
 
   ##
   # Converts +document+ to text and writes it to the pager
 
-  def display document
+  def display(document)
     page do |io|
       f = formatter(io)
       f.width = @width if @width and f.respond_to?(:width)
@@ -807,7 +817,7 @@ or the PAGER environment variable.
   ##
   # Outputs formatted RI data for class +name+.  Groups undocumented classes
 
-  def display_class name
+  def display_class(name)
     return if name =~ /#|\./
 
     found, klasses, includes, extends =
@@ -823,11 +833,13 @@ or the PAGER environment variable.
   ##
   # Outputs formatted RI data for method +name+
 
-  def display_method name
+  def display_method(name)
     out = RDoc::Markup::Document.new
 
     add_method out, name
 
+    expand_rdoc_refs_at_the_bottom(out)
+
     display out
   end
 
@@ -837,7 +849,7 @@ or the PAGER environment variable.
   # 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
+  def display_name(name)
     if name =~ /\w:(\w|$)/ then
       display_page name
       return true
@@ -866,7 +878,7 @@ or the PAGER environment variable.
   ##
   # Displays each name in +name+
 
-  def display_names names
+  def display_names(names)
     names.each do |name|
       name = expand_name name
 
@@ -877,7 +889,7 @@ or the PAGER environment variable.
   ##
   # Outputs formatted RI data for page +name+.
 
-  def display_page name
+  def display_page(name)
     store_name, page_name = name.split ':', 2
 
     store = @stores.find { |s| s.source == store_name }
@@ -902,13 +914,13 @@ or the PAGER environment variable.
 
     page = store.load_page page_name
 
-    display page.comment
+    display page.comment.parse
   end
 
   ##
   # Outputs a formatted RI page list for the pages in +store+.
 
-  def display_page_list store, pages = store.cache[:pages], search = nil
+  def display_page_list(store, pages = store.cache[:pages], search = nil)
     out = RDoc::Markup::Document.new
 
     title = if search then
@@ -952,13 +964,13 @@ or the PAGER environment variable.
   # Expands abbreviated klass +klass+ into a fully-qualified class.  "Zl::Da"
   # will be expanded to Zlib::DataError.
 
-  def expand_class klass
+  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
-        suggestions = DidYouMean::SpellChecker.new(dictionary: class_names).correct(klass)
-        raise NotFoundError.new(klass, suggestions)
+        suggestion_proc = -> { DidYouMean::SpellChecker.new(dictionary: class_names).correct(klass) }
+        raise NotFoundError.new(klass, suggestion_proc)
       else
         raise NotFoundError, klass
       end
@@ -970,7 +982,7 @@ or the PAGER environment variable.
   # Expands the class portion of +name+ into a fully-qualified class.  See
   # #expand_class.
 
-  def expand_name name
+  def expand_name(name)
     klass, selector, method = parse_name name
 
     return [selector, method].join if klass.empty?
@@ -986,7 +998,7 @@ or the PAGER environment variable.
   ##
   # Filters the methods in +found+ trying to find a match for +name+.
 
-  def filter_methods found, name
+  def filter_methods(found, name)
     regexp = name_regexp name
 
     filtered = found.find_all do |store, methods|
@@ -1004,7 +1016,7 @@ or the PAGER environment variable.
   # types of methods to look up (from #method_type), and the method name being
   # searched for
 
-  def find_methods name
+  def find_methods(name)
     klass, selector, method = parse_name name
 
     types = method_type selector
@@ -1044,43 +1056,13 @@ or the PAGER environment variable.
     self
   end
 
-  ##
-  # Finds the given +pager+ for jruby.  Returns an IO if +pager+ was found.
-  #
-  # Returns false if +pager+ does not exist.
-  #
-  # Returns nil if the jruby JVM doesn't support ProcessBuilder redirection
-  # (1.6 and older).
-
-  def find_pager_jruby pager
-    require 'java'
-    require 'shellwords'
-
-    return nil unless java.lang.ProcessBuilder.constants.include? :Redirect
-
-    pager = Shellwords.split pager
-
-    pb = java.lang.ProcessBuilder.new(*pager)
-    pb = pb.redirect_output java.lang.ProcessBuilder::Redirect::INHERIT
-
-    @jruby_pager_process = pb.start
-
-    input = @jruby_pager_process.output_stream
-
-    io = input.to_io
-    io.sync = true
-    io
-  rescue java.io.IOException
-    false
-  end
-
   ##
   # 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
+  def find_store(name)
     @stores.each do |store|
       source = store.source
 
@@ -1113,6 +1095,10 @@ or the PAGER environment variable.
   def interactive
     puts "\nEnter the method name you want to look up."
 
+    begin
+      require 'readline'
+    rescue LoadError
+    end
     if defined? Readline then
       Readline.completion_proc = method :complete
       puts "You can use tab to autocomplete."
@@ -1122,7 +1108,7 @@ or the PAGER environment variable.
 
     loop do
       name = if defined? Readline then
-               Readline.readline ">> "
+               Readline.readline ">> ", true
              else
                print ">> "
                $stdin.gets
@@ -1141,22 +1127,11 @@ or the PAGER environment variable.
     exit
   end
 
-  ##
-  # Is +file+ in ENV['PATH']?
-
-  def in_path? file
-    return true if file =~ %r%\A/% and File.exist? file
-
-    ENV['PATH'].split(File::PATH_SEPARATOR).any? do |path|
-      File.exist? File.join(path, file)
-    end
-  end
-
   ##
   # Lists classes known to ri starting with +names+.  If +names+ is empty all
   # known classes are shown.
 
-  def list_known_classes names = []
+  def list_known_classes(names = [])
     classes = []
 
     stores.each do |store|
@@ -1188,7 +1163,7 @@ or the PAGER environment variable.
   ##
   # Returns an Array of methods matching +name+
 
-  def list_methods_matching name
+  def list_methods_matching(name)
     found = []
 
     find_methods name do |store, klass, ancestor, types, method|
@@ -1227,7 +1202,7 @@ or the PAGER environment variable.
   # 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
+  def load_method(store, cache, klass, type, name)
     methods = store.public_send(cache)[klass]
 
     return unless methods
@@ -1240,9 +1215,10 @@ or the PAGER environment variable.
 
     store.load_method klass, "#{type}#{method}"
   rescue RDoc::Store::MissingFileError => e
-    comment = RDoc::Comment.new("missing documentation at #{e.file}").parse
+    comment = RDoc::Comment.new("missing documentation at #{e.file}")
+    comment.parse
 
-    method = RDoc::AnyMethod.new nil, name
+    method = RDoc::AnyMethod.new name
     method.comment = comment
     method
   end
@@ -1250,7 +1226,7 @@ or the PAGER environment variable.
   ##
   # Returns an Array of RI data for methods matching +name+
 
-  def load_methods_matching name
+  def load_methods_matching(name)
     found = []
 
     find_methods name do |store, klass, ancestor, types, method|
@@ -1271,7 +1247,7 @@ or the PAGER environment variable.
   ##
   # Returns a filtered list of methods matching +name+
 
-  def lookup_method name
+  def lookup_method(name)
     found = load_methods_matching name
 
     if found.empty?
@@ -1283,8 +1259,8 @@ or the PAGER environment variable.
           methods.push(*store.instance_methods[klass]) if [:instance, :both].include? types
         end
         methods = methods.uniq
-        suggestions = DidYouMean::SpellChecker.new(dictionary: methods).correct(method_name)
-        raise NotFoundError.new(name, suggestions)
+        suggestion_proc = -> { DidYouMean::SpellChecker.new(dictionary: methods).correct(method_name) }
+        raise NotFoundError.new(name, suggestion_proc)
       else
         raise NotFoundError, name
       end
@@ -1296,9 +1272,7 @@ or the PAGER environment variable.
   ##
   # Builds a RDoc::Markup::Document from +found+, +klasses+ and +includes+
 
-  def method_document name, filtered
-    out = RDoc::Markup::Document.new
-
+  def method_document(out, name, filtered)
     out << RDoc::Markup::Heading.new(1, name)
     out << RDoc::Markup::BlankLine.new
 
@@ -1314,7 +1288,7 @@ or the PAGER environment variable.
   ##
   # Returns the type of method (:both, :instance, :class) for +selector+
 
-  def method_type selector
+  def method_type(selector)
     case selector
     when '.', nil then :both
     when '#'      then :instance
@@ -1326,7 +1300,7 @@ or the PAGER environment variable.
   # Returns a regular expression for +name+ that will match an
   # RDoc::AnyMethod's name.
 
-  def name_regexp name
+  def name_regexp(name)
     klass, type, name = parse_name name
 
     case type
@@ -1346,7 +1320,6 @@ or the PAGER environment variable.
         yield pager
       ensure
         pager.close
-        @jruby_pager_process.wait_for if @jruby_pager_process
       end
     else
       yield $stdout
@@ -1370,7 +1343,7 @@ or the PAGER environment variable.
   # NOTE: Given Foo::Bar, Bar is considered a class even though it may be a
   # method
 
-  def parse_name name
+  def parse_name(name)
     parts = name.split(/(::?|#|\.)/)
 
     if parts.length == 1 then
@@ -1402,14 +1375,14 @@ or the PAGER environment variable.
   # 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:
-    comment = klass.comment
+  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 comment.empty? and
+    if document.empty? and
        instance_methods.empty? and class_methods.empty? then
       also_in << store
       return
@@ -1417,7 +1390,7 @@ or the PAGER environment variable.
 
     add_from out, store
 
-    class_document_comment out, comment
+    class_document_comment out, document
 
     if class_methods or instance_methods or not klass.constants.empty? then
       out << RDoc::Markup::Rule.new(1)
@@ -1432,7 +1405,7 @@ or the PAGER environment variable.
     add_method_documentation out, klass if @show_all
   end
 
-  def render_method out, store, method, name # :nodoc:
+  def render_method(out, store, method, name) # :nodoc:
     out << RDoc::Markup::Paragraph.new("(from #{store.friendly_path})")
 
     unless name =~ /^#{Regexp.escape method.parent_name}/ then
@@ -1442,6 +1415,8 @@ or the PAGER environment variable.
     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
@@ -1452,7 +1427,7 @@ or the PAGER environment variable.
     end
   end
 
-  def render_method_arguments out, arglists # :nodoc:
+  def render_method_arguments(out, arglists) # :nodoc:
     return unless arglists
 
     arglists = arglists.chomp.split "\n"
@@ -1461,25 +1436,29 @@ or the PAGER environment variable.
     out << RDoc::Markup::Rule.new(1)
   end
 
-  def render_method_comment out, method, alias_for = nil# :nodoc:
+  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
+        out << method.comment.parse
       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
+      out << alias_for.comment.parse
       out << RDoc::Markup::BlankLine.new
     else
       out << RDoc::Markup::BlankLine.new
-      out << method.comment
+      out << method.comment.parse
       out << RDoc::Markup::BlankLine.new
     end
   end
 
-  def render_method_superclass out, method # :nodoc:
+  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
 
@@ -1514,27 +1493,14 @@ or the PAGER environment variable.
   def setup_pager
     return if @use_stdout
 
-    jruby = RUBY_ENGINE == 'jruby'
-
     pagers = [ENV['RI_PAGER'], ENV['PAGER'], 'pager', 'less', 'more']
 
+    require 'shellwords'
     pagers.compact.uniq.each do |pager|
-      next unless pager
-
-      pager_cmd = pager.split(' ').first
-
-      next unless in_path? pager_cmd
-
-      if jruby then
-        case io = find_pager_jruby(pager)
-        when nil   then break
-        when false then next
-        else            io
-        end
-      else
-        io = IO.popen(pager, 'w') rescue next
-      end
+      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
 
       @paging = true
@@ -1561,7 +1527,7 @@ or the PAGER environment variable.
 
     extra_doc_dirs = @stores.map {|s| s.type == :extra ? s.path : nil}.compact
 
-    server.mount '/', RDoc::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
@@ -1569,4 +1535,38 @@ or the PAGER environment variable.
     server.start
   end
 
+  RDOC_REFS_REGEXP = /\[rdoc-ref:([\w.]+)(@.*)?\]/
+
+  def expand_rdoc_refs_at_the_bottom(out)
+    return unless @expand_refs
+
+    extracted_rdoc_refs = []
+
+    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
+
+      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.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