| Current File : //opt/alt/ruby33/share/gems/gems/rdoc-6.6.3.1/lib/rdoc/ri/driver.rb |
# frozen_string_literal: true
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
##
# Name that wasn't found
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
##
# Show all method documentation following a class or module
attr_accessor :show_all
##
# An RDoc::RI::Store for each entry in the RI path
attr_accessor :stores
##
# Controls the user of the pager vs $stdout
attr_accessor :use_stdout
##
# Default options for ri
def self.default_options
options = {}
options[:interactive] = false
options[:profile] = false
options[:show_all] = false
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] = []
return options
end
##
# Dump +data_path+ using pp
def self.dump data_path
require 'pp'
File.open data_path, 'rb' do |io|
pp Marshal.load(io.read)
end
end
##
# Parses +argv+ and returns a Hash of options
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
opt.summary_indent = ' ' * 4
opt.banner = <<-EOT
Usage: #{opt.program_name} [options] [name ...]
Where name can be:
Class | Module | Module::Class
Class::method | Class#method | Class.method | method
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.
A '.' matches either class or instance methods, while #method
matches only instance and ::method matches only class methods.
README and other files may be displayed by prefixing them with the gem name
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
#{opt.program_name} File
#{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:
#{opt.program_name} 'Array.[]'
#{opt.program_name} compact\\!
To see the default directories #{opt.program_name} will search, run:
#{opt.program_name} --list-doc-dirs
Specifying the --system, --site, --home, --gems, or --doc-dir options
will limit ri to searching only the specified directories.
ri options may be set in the RI environment variable.
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.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.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.on("--[no-]list", "-l",
"List classes ri knows about.") do |list|
options[:list] = list
end
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.separator nil
opt.on("-T",
"Synonym for --no-pager.") do
options[:use_stdout] = true
end
opt.separator nil
opt.on("--width=WIDTH", "-w", OptionParser::DecimalInteger,
"Set the width of the output.") do |width|
options[:width] = width
end
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.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
opt.separator nil
opt.on("--help", "-h",
"Show help and exit.") do
puts opts
exit
end
opt.separator nil
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.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.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"
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-]system",
"Include documentation from Ruby's",
"standard library. Defaults to true.") do |value|
options[:use_system] = value
end
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.separator nil
opt.on("--[no-]gems",
"Include documentation from RubyGems.",
"Defaults to true.") do |value|
options[:use_gems] = value
end
opt.separator nil
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.on("--[no-]profile",
"Run with the ruby profiler.") do |value|
options[:profile] = value
end
opt.separator nil
opt.on("--dump=CACHE", File,
"Dump data from an ri cache or data file.") do |value|
options[:dump_path] = value
end
end
argv = ENV['RI'].to_s.split(' ').concat argv
opts.parse! argv
options[:names] = argv
options[:use_stdout] ||= !$stdout.tty?
options[:use_stdout] ||= options[:interactive]
options[:width] ||= 72
options
rescue OptionParser::InvalidArgument, OptionParser::InvalidOption => e
puts opts
puts
puts e
exit 1
end
##
# Runs the ri command line executable using +argv+
def self.run argv = ARGV
options = process_args argv
if options[:dump_path] then
dump options[:dump_path]
return
end
ri = new options
ri.run
end
##
# Creates a new driver using +initial_options+ from ::process_args
def initialize initial_options = {}
@paging = false
@classes = nil
options = self.class.default_options.update(initial_options)
@formatter_klass = options[:formatter]
require 'profile' if options[:profile]
@names = options[:names]
@list = options[:list]
@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
store = RDoc::RI::Store.new path, type
store.load_cache
@stores << store
end
@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]
end
##
# Adds paths for undocumented classes +also_in+ to +out+
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:")
paths = RDoc::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+.
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'
superclass = superclass.full_name unless String === superclass
"#{name} < #{superclass}"
end
out << RDoc::Markup::Heading.new(1, heading)
out << RDoc::Markup::BlankLine.new
end
##
# Adds "(from ...)" to +out+ for +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
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.
def add_extension_modules out, type, extensions
return if extensions.empty?
out << RDoc::Markup::Rule.new(1)
out << RDoc::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
end
end
end
##
# 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})")
wout, with = modules.partition { |incl| incl.comment.empty? }
out << RDoc::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
end
unless wout.empty? then
verb = RDoc::Markup::Verbatim.new
wout.each do |incl|
verb.push incl.name, "\n"
end
out << verb
end
end
##
# 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})")
if include.comment then
out << RDoc::Markup::BlankLine.new
out << include.comment
end
end
##
# Adds +includes+ to +out+
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
end
##
# 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
end
end
end
##
# Adds a list of +methods+ to +out+ with a heading of +name+
def add_method_list out, methods, name
return if methods.empty?
out << RDoc::Markup::Heading.new(1, "#{name}:")
out << RDoc::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
out << RDoc::Markup::BlankLine.new
end
##
# Returns ancestor classes of +klass+
def ancestors_of klass
ancestors = []
unexamined = [klass]
seen = []
loop do
break if unexamined.empty?
current = unexamined.shift
seen << current
stores = classes[current]
next unless stores and not stores.empty?
klasses = stores.flat_map do |store|
store.ancestors[current] || []
end.uniq
klasses = klasses - seen
ancestors.concat klasses
unexamined.concat klasses
end
ancestors.reverse
end
##
# For RubyGems backwards compatibility
def class_cache # :nodoc:
end
##
# Builds a RDoc::Markup::Document from +found+, +klasess+ and +includes+
def class_document name, found, klasses, includes, extends
also_in = []
out = RDoc::Markup::Document.new
add_class out, name, klasses
add_includes out, includes
add_extends out, extends
found.each do |store, klass|
render_class out, store, klass, also_in
end
add_also_in out, also_in
out
end
##
# Adds the class +comment+ to +out+.
def class_document_comment out, comment # :nodoc:
unless comment.empty? then
out << RDoc::Markup::Rule.new(1)
if comment.merged? then
parts = comment.parts
parts = parts.zip [RDoc::Markup::BlankLine.new] * parts.length
parts.flatten!
parts.pop
out.concat parts
else
out << comment
end
end
end
##
# Adds the constants from +klass+ to the Document +out+.
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
constants = klass.constants.sort_by { |constant| constant.name }
list.items.concat constants.map { |constant|
parts = constant.comment.parts if constant.comment
parts << RDoc::Markup::Paragraph.new('[not documented]') if
parts.empty?
RDoc::Markup::ListItem.new(constant.name, *parts)
}
out << list
out << RDoc::Markup::BlankLine.new
end
##
# Hash mapping a known class or module to the stores it can be loaded from
def classes
return @classes if @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
##
# 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
extends.reject! do |modules,| modules.empty? end
includes.reject! do |modules,| modules.empty? end
[found, klasses, includes, extends]
end
##
# Completes +name+ based on the caches. For Readline
def complete name
completions = []
klass, selector, method = parse_name name
complete_klass name, klass, selector, method, completions
complete_method name, klass, selector, completions
completions.sort.uniq
end
def complete_klass name, klass, selector, method, completions # :nodoc:
klasses = classes.keys
# may need to include Foo when given Foo::
klass_name = method ? name : klass
if name !~ /#|\./ then
completions.replace klasses.grep(/^#{Regexp.escape klass_name}[^:]*$/)
completions.concat klasses.grep(/^#{Regexp.escape name}[^:]*$/) if
name =~ /::$/
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
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}"
end
completions.concat methods
end
end
##
# 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
io.write text
end
end
##
# Outputs formatted RI data for class +name+. Groups undocumented classes
def display_class name
return if name =~ /#|\./
found, klasses, includes, extends =
classes_and_includes_and_extends_for name
return if found.empty?
out = class_document name, found, klasses, includes, extends
display out
end
##
# Outputs formatted RI data for method +name+
def display_method name
out = RDoc::Markup::Document.new
add_method out, name
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.
def display_name name
if name =~ /\w:(\w|$)/ then
display_page name
return true
end
return true if display_class 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?
raise if matches.empty?
page do |io|
io.puts "#{name} not found, maybe you meant:"
io.puts
io.puts matches.sort.join("\n")
end
false
end
##
# Displays each name in +name+
def display_names names
names.each do |name|
name = expand_name name
display_name name
end
end
##
# Outputs formatted RI data for page +name+.
def display_page name
store_name, page_name = name.split ':', 2
store = @stores.find { |s| s.source == store_name }
return display_page_list store if page_name.empty?
pages = store.cache[:pages]
unless pages.include? page_name then
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
page_name = found_names.first
end
page = store.load_page page_name
display page.comment
end
##
# 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
title = if search then
"#{search} pages"
else
'Pages'
end
out << RDoc::Markup::Heading.new(1, "#{title} in #{store.friendly_path}")
out << RDoc::Markup::BlankLine.new
list = RDoc::Markup::List.new(:BULLET)
pages.each do |page|
list << RDoc::Markup::Paragraph.new(page)
end
out << list
display out
end
def check_did_you_mean # :nodoc:
if defined? DidYouMean::SpellChecker
true
else
begin
require 'did_you_mean'
if defined? DidYouMean::SpellChecker
true
else
false
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
end
end
ary.first
end
##
# Expands the class portion of +name+ into a fully-qualified class. See
# #expand_class.
def expand_name name
klass, selector, method = parse_name name
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
##
# Filters the methods in +found+ trying to find a match for +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
return filtered unless filtered.empty?
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
def find_methods name
klass, selector, method = parse_name name
types = method_type selector
klasses = nil
ambiguous = klass.empty?
if ambiguous then
klasses = classes.keys
else
klasses = ancestors_of klass
klasses.unshift klass
end
methods = []
klasses.each do |ancestor|
ancestors = classes[ancestor]
next unless ancestors
klass = ancestor if ambiguous
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.each do |item|
yield(*item) # :yields: store, klass, ancestor, types, method
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
def find_store name
@stores.each do |store|
source = store.source
return source if source == name
return source if
store.type == :gem and source =~ /^#{Regexp.escape name}-\d/
end
raise RDoc::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
##
# Runs ri interactively using Readline if it is available.
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."
end
puts "Enter a blank line to exit.\n\n"
loop do
name = if defined? Readline then
Readline.readline ">> "
else
print ">> "
$stdin.gets
end
return if name.nil? or name.empty?
begin
display_name expand_name(name.strip)
rescue NotFoundError => e
puts e.message
end
end
rescue Interrupt
exit
end
##
# Lists classes known to ri starting with +names+. If +names+ is empty all
# known classes are shown.
def list_known_classes names = []
classes = []
stores.each do |store|
classes << store.module_names
end
classes = classes.flatten.uniq.sort
unless names.empty? then
filter = Regexp.union names.map { |name| /^#{name}/ }
classes = classes.grep filter
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 ', '}:"
end
io.puts
end
io.puts classes.join("\n")
end
end
##
# Returns an Array of methods matching +name+
def list_methods_matching name
found = []
find_methods name do |store, klass, ancestor, types, method|
if types == :instance or types == :both then
methods = store.instance_methods[ancestor]
if methods then
matches = methods.grep(/^#{Regexp.escape method.to_s}/)
matches = matches.map do |match|
"#{klass}##{match}"
end
found.concat matches
end
end
if types == :class or types == :both then
methods = store.class_methods[ancestor]
next unless methods
matches = methods.grep(/^#{Regexp.escape method.to_s}/)
matches = matches.map do |match|
"#{klass}::#{match}"
end
found.concat matches
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.
def load_method store, cache, klass, type, name
methods = store.public_send(cache)[klass]
return unless methods
method = methods.find do |method_name|
method_name == name
end
return unless method
store.load_method klass, "#{type}#{method}"
rescue RDoc::Store::MissingFileError => e
comment = RDoc::Comment.new("missing documentation at #{e.file}").parse
method = RDoc::AnyMethod.new nil, name
method.comment = comment
method
end
##
# Returns an Array of RI data for methods matching +name+
def load_methods_matching name
found = []
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, :instance_methods, ancestor, '#', method) if
[:instance, :both].include? types
found << [store, methods.compact]
end
found.reject do |path, methods| methods.empty? end
end
##
# Returns a filtered list of 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
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
filter_methods found, name
end
##
# Builds a RDoc::Markup::Document from +found+, +klasses+ and +includes+
def method_document name, filtered
out = RDoc::Markup::Document.new
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
out
end
##
# 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
##
# Returns a regular expression for +name+ that will match an
# RDoc::AnyMethod's 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
##
# Paginates output through a pager program.
def page
if pager = setup_pager then
begin
yield pager
ensure
pager.close
end
else
yield $stdout
end
rescue Errno::EPIPE
ensure
@paging = false
end
##
# Are we using a pager?
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 then
if parts.first =~ /^[a-z]|^([%&*+\/<>^`|~-]|\+@|-@|<<|<=>?|===?|=>|=~|>>|\[\]=?|~@)$/ then
type = '.'
meth = parts.pop
else
type = nil
meth = nil
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
[klass, type, meth]
end
##
# 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
# 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
instance_methods.empty? and class_methods.empty? then
also_in << store
return
end
add_from out, store
class_document_comment out, comment
if class_methods or instance_methods or not klass.constants.empty? then
out << RDoc::Markup::Rule.new(1)
end
class_document_constants out, klass
add_method_list out, class_methods, 'Class methods'
add_method_list out, instance_methods, 'Instance methods'
add_method_list out, attributes, 'Attributes'
add_method_documentation out, klass if @show_all
end
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
out << RDoc::Markup::Heading.new(3, "Implementation from #{method.parent_name}")
end
out << RDoc::Markup::Rule.new(1)
render_method_arguments out, method.arglists
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
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 << RDoc::Markup::BlankLine.new
out << method.comment
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 << RDoc::Markup::BlankLine.new
else
out << RDoc::Markup::BlankLine.new
out << method.comment
out << RDoc::Markup::BlankLine.new
end
end
def render_method_superclass out, method # :nodoc:
return unless
method.respond_to?(:superclass_method) and method.superclass_method
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 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.
def setup_pager
return if @use_stdout
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?
io = IO.popen(pager, 'w') rescue next
next if $? and $?.pid == io.pid and $?.exited? # pager didn't work
@paging = true
return io
end
@use_stdout = true
nil
end
##
# 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
server = WEBrick::HTTPServer.new :Port => @server
extra_doc_dirs = @stores.map {|s| s.type == :extra ? s.path : nil}.compact
server.mount '/', RDoc::Servlet, nil, extra_doc_dirs
trap 'INT' do server.shutdown end
trap 'TERM' do server.shutdown end
server.start
end
end