This is the driver for generating RDoc output. It handles file parsing and generation of output.
To use this class to generate RDoc output via the API, the recommended way is:
rdoc = RDoc::RDoc.new options = rdoc.load_options rdoc.document options
You can also generate output like the rdoc executable:
rdoc = RDoc::RDoc.new rdoc.document argv
Where argv is an array of strings, each corresponding to an argument you'd give rdoc on the command line. See rdoc --help for details.
This is the list of supported output generators
generator[RW]
Generator instance used for creating output
last_modified[R]
Hash of files and their last modified times.
stats[R]
Accessor for statistics. Available after each call to parse_files
store[R]
The current documentation store
Public Class Methodsadd_generator(klass) click to toggle source
Add klass that can generate output after parsing
def self.add_generator(klass) name = klass.name.sub(/^RDoc::Generator::/, '').downcase GENERATORS[name] = klass end
current() click to toggle source
Active RDoc::RDoc instance
def self.current @current end
current=(rdoc) click to toggle source
Sets the active RDoc::RDoc instance
def self.current= rdoc @current = rdoc end
new() click to toggle source
Creates a new RDoc::RDoc instance. Call document to parse files and generate documentation.
def initialize
@current = nil
@generator = nil
@last_modified = {}
@old_siginfo = nil
@options = nil
@stats = nil
@store = nil
end Public Instance Methods
document(options) click to toggle source
Generates documentation or a coverage report depending upon the settings in options.
options can be either an RDoc::Options instance or an array of strings equivalent to the strings that would be passed on the command line like %w[-q -o doc -t My\ Doc\ Title]. document will automatically call RDoc::Options#finish if an options instance was given.
For a list of options, see either RDoc::Options or rdoc --help.
By default, output will be stored in a directory called âdocâ below the current directory, so make sure you're somewhere writable before invoking.
def document options
self.store = RDoc::Store.new
if RDoc::Options === options then
@options = options
@options.finish
else
@options = load_options
@options.parse options
end
if @options.pipe then
handle_pipe
exit
end
unless @options.coverage_report then
@last_modified = setup_output_dir @options.op_dir, @options.force_update
end
@store.encoding = @options.encoding
@store.dry_run = @options.dry_run
@store.main = @options.main_page
@store.title = @options.title
@store.path = @options.op_dir
@start_time = Time.now
@store.load_cache
file_info = parse_files @options.files
@options.default_title = "RDoc Documentation"
@store.complete @options.visibility
@stats.coverage_level = @options.coverage_report
if @options.coverage_report then
puts
puts @stats.report.accept RDoc::Markup::ToRdoc.new
elsif file_info.empty? then
$stderr.puts "\nNo newer files." unless @options.quiet
else
gen_klass = @options.generator
@generator = gen_klass.new @store, @options
generate
end
if @stats and (@options.coverage_report or not @options.quiet) then
puts
puts @stats.summary.accept RDoc::Markup::ToRdoc.new
end
exit @stats.fully_documented? if @options.coverage_report
end
error(msg) click to toggle source
Report an error message and exit
def error(msg) raise RDoc::Error, msg end
gather_files(files) click to toggle source
Gathers a set of parseable files from the files and directories listed in files.
def gather_files files
files = ["."] if files.empty?
file_list = normalized_file_list files, true, @options.exclude
file_list = remove_unparseable(file_list)
if file_list.count {|name, mtime|
file_list[name] = @last_modified[name] unless mtime
mtime
} > 0
@last_modified.replace file_list
file_list.keys.sort
else
[]
end
end
generate() click to toggle source
Generates documentation for file_info (from parse_files) into the output dir using the generator selected by the RDoc options
def generate
if @options.dry_run then
@generator.generate
else
Dir.chdir @options.op_dir do
unless @options.quiet then
$stderr.puts "\nGenerating #{@generator.class.name.sub(/^.*::/, '')} format into #{Dir.pwd}..."
end
@generator.generate
update_output_dir '.', @start_time, @last_modified
end
end
end
handle_pipe() click to toggle source
Turns RDoc from stdin into HTML
def handle_pipe @html = RDoc::Markup::ToHtml.new @options parser = RDoc::Text::MARKUP_FORMAT[@options.markup] document = parser.parse $stdin.read out = @html.convert document $stdout.write out end
install_siginfo_handler() click to toggle source
Installs a siginfo handler that prints the current filename.
def install_siginfo_handler
return unless Signal.list.include? 'INFO'
@old_siginfo = trap 'INFO' do
puts @current if @current
end
end
list_files_in_directory(dir) click to toggle source
Return a list of the files to be processed in a directory. We know that this directory doesn't have a .document file, so we're looking for real files. However we may well contain subdirectories which must be tested for .document files.
def list_files_in_directory dir files = Dir.glob File.join(dir, "*") normalized_file_list files, false, @options.exclude end
load_options() click to toggle source
Loads options from .rdoc_options if the file exists, otherwise creates a new RDoc::Options instance.
def load_options
options_file = File.expand_path '.rdoc_options'
return RDoc::Options.new unless File.exist? options_file
RDoc.load_yaml
begin
options = YAML.safe_load_file '.rdoc_options', permitted_classes: [RDoc::Options, Symbol]
rescue Psych::SyntaxError
raise RDoc::Error, "#{options_file} is not a valid rdoc options file"
end
return RDoc::Options.new unless options
raise RDoc::Error, "#{options_file} is not a valid rdoc options file" unless
RDoc::Options === options or Hash === options
if Hash === options
options = RDoc::Options.new options
end
options
end
normalized_file_list(relative_files, force_doc = false, exclude_pattern = nil) click to toggle source
Given a list of files and directories, create a list of all the Ruby files they contain.
If force_doc is true we always add the given files, if false, only add files that we guarantee we can parse. It is true when looking at files given on the command line, false when recursing through subdirectories.
The effect of this is that if you want a file with a non-standard extension parsed, you must name it explicitly.
def normalized_file_list(relative_files, force_doc = false,
exclude_pattern = nil)
file_list = {}
relative_files.each do |rel_file_name|
rel_file_name = rel_file_name.sub(/^\.\//, '')
next if rel_file_name.end_with? 'created.rid'
next if exclude_pattern && exclude_pattern =~ rel_file_name
stat = File.stat rel_file_name rescue next
case type = stat.ftype
when "file" then
mtime = (stat.mtime unless (last_modified = @last_modified[rel_file_name] and
stat.mtime.to_i <= last_modified.to_i))
if force_doc or RDoc::Parser.can_parse(rel_file_name) then
file_list[rel_file_name] = mtime
end
when "directory" then
next if rel_file_name == "CVS" || rel_file_name == ".svn"
created_rid = File.join rel_file_name, "created.rid"
next if File.file? created_rid
dot_doc = File.join rel_file_name, RDoc::DOT_DOC_FILENAME
if File.file? dot_doc then
file_list.update(parse_dot_doc_file(rel_file_name, dot_doc))
else
file_list.update(list_files_in_directory(rel_file_name))
end
else
warn "rdoc can't parse the #{type} #{rel_file_name}"
end
end
file_list
end
output_flag_file(op_dir) click to toggle source
Return the path name of the flag file in an output directory.
def output_flag_file(op_dir) File.join op_dir, "created.rid" end
parse_dot_doc_file(in_dir, filename) click to toggle source
The .document file contains a list of file and directory name patterns, representing candidates for documentation. It may also contain comments (starting with '#')
def parse_dot_doc_file in_dir, filename
patterns = File.read(filename).gsub(/#.*/, '')
result = {}
patterns.split(' ').each do |patt|
candidates = Dir.glob(File.join(in_dir, patt))
result.update normalized_file_list(candidates, false, @options.exclude)
end
result
end
parse_file(filename) click to toggle source
Parses filename and returns an RDoc::TopLevel
def parse_file filename
encoding = @options.encoding
filename = filename.encode encoding
@stats.add_file filename
return if RDoc::Parser.binary? filename
content = RDoc::Encoding.read_file filename, encoding
return unless content
filename_path = Pathname(filename).expand_path
begin
relative_path = filename_path.relative_path_from @options.root
rescue ArgumentError
relative_path = filename_path
end
if @options.page_dir and
relative_path.to_s.start_with? @options.page_dir.to_s then
relative_path =
relative_path.relative_path_from @options.page_dir
end
top_level = @store.add_file filename, relative_name: relative_path.to_s
parser = RDoc::Parser.for top_level, filename, content, @options, @stats
return unless parser
parser.scan
top_level.classes_or_modules.each do |cm|
cm.done_documenting = false
end
top_level
rescue Errno::EACCES => e
$stderr.puts <<-EOF
Unable to read #{filename}, #{e.message}
Please check the permissions for this file. Perhaps you do not have access to
it or perhaps the original author's permissions are to restrictive. If the
this is not your library please report a bug to the author.
EOF
rescue => e
$stderr.puts <<-EOF
Before reporting this, could you check that the file you're documenting
has proper syntax:
#{Gem.ruby} -c #{filename}
RDoc is not a full Ruby parser and will fail when fed invalid ruby programs.
The internal error was:
\t(#{e.class}) #{e.message}
EOF
$stderr.puts e.backtrace.join("\n\t") if $DEBUG_RDOC
raise e
nil
end
parse_files(files) click to toggle source
Parse each file on the command line, recursively entering directories.
def parse_files files
file_list = gather_files files
@stats = RDoc::Stats.new @store, file_list.length, @options.verbosity
return [] if file_list.empty?
original_options = @options.dup
@stats.begin_adding
file_info = file_list.map do |filename|
@current = filename
parse_file filename
end.compact
@stats.done_adding
@options = original_options
file_info
end
remove_siginfo_handler() click to toggle source
Removes a siginfo handler and replaces the previous
def remove_siginfo_handler return unless Signal.list.key? 'INFO' handler = @old_siginfo || 'DEFAULT' trap 'INFO', handler end
remove_unparseable(files) click to toggle source
Removes file extensions known to be unparseable from files and TAGS files for emacs and vim.
def remove_unparseable files
files.reject do |file, *|
file =~ /\.(?:class|eps|erb|scpt\.txt|svg|ttf|yml)$/i or
(file =~ /tags$/i and
File.open(file, 'rb') { |io|
io.read(100) =~ /\A(\f\n[^,]+,\d+$|!_TAG_)/
})
end
end
setup_output_dir(dir, force) click to toggle source
Create an output dir if it doesn't exist. If it does exist, but doesn't contain the flag file created.rid then we refuse to use it, as we may clobber some manually generated documentation
def setup_output_dir(dir, force)
flag_file = output_flag_file dir
last = {}
if @options.dry_run then
elsif File.exist? dir then
error "#{dir} exists and is not a directory" unless File.directory? dir
begin
File.open flag_file do |io|
unless force then
Time.parse io.gets
io.each do |line|
file, time = line.split "\t", 2
time = Time.parse(time) rescue next
last[file] = time
end
end
end
rescue SystemCallError, TypeError
error <<-ERROR
Directory #{dir} already exists, but it looks like it isn't an RDoc directory.
Because RDoc doesn't want to risk destroying any of your existing files,
you'll need to specify a different output directory name (using the --op <dir>
option)
ERROR
end unless @options.force_output
else
FileUtils.mkdir_p dir
FileUtils.touch flag_file
end
last
end
store=(store) click to toggle source
Sets the current documentation tree to store and sets the store's rdoc driver to this instance.
def store= store @store = store @store.rdoc = self end
update_output_dir(op_dir, time, last = {}) click to toggle source
Update the flag file in an output directory.
def update_output_dir(op_dir, time, last = {})
return if @options.dry_run or not @options.update_output_dir
unless ENV['SOURCE_DATE_EPOCH'].nil?
time = Time.at(ENV['SOURCE_DATE_EPOCH'].to_i).gmtime
end
File.open output_flag_file(op_dir), "w" do |f|
f.puts time.rfc2822
last.each do |n, t|
f.puts "#{n}\t#{t.rfc2822}"
end
end
end
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4