diff options
Diffstat (limited to 'jni/ruby/lib/rdoc/ri')
| -rw-r--r-- | jni/ruby/lib/rdoc/ri/driver.rb | 1497 | ||||
| -rw-r--r-- | jni/ruby/lib/rdoc/ri/formatter.rb | 5 | ||||
| -rw-r--r-- | jni/ruby/lib/rdoc/ri/paths.rb | 187 | ||||
| -rw-r--r-- | jni/ruby/lib/rdoc/ri/store.rb | 6 | ||||
| -rw-r--r-- | jni/ruby/lib/rdoc/ri/task.rb | 71 |
5 files changed, 1766 insertions, 0 deletions
diff --git a/jni/ruby/lib/rdoc/ri/driver.rb b/jni/ruby/lib/rdoc/ri/driver.rb new file mode 100644 index 0000000..39064c1 --- /dev/null +++ b/jni/ruby/lib/rdoc/ri/driver.rb @@ -0,0 +1,1497 @@ +require 'abbrev' +require 'optparse' + +begin + require 'readline' +rescue LoadError +end + +begin + require 'win32console' +rescue LoadError +end + +require 'rdoc' + +## +# For RubyGems backwards compatibility + +require 'rdoc/ri/formatter' + +## +# 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 + + ## + # Name that wasn't found + + alias name message + + def message # :nodoc: + "Nothing known about #{super}" + 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_cache] = 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] = [] + + return options + end + + ## + # Dump +data_path+ using pp + + def self.dump data_path + require 'pp' + + 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] [names...] + +Where name can be: + + Class | Module | Module::Class + + Class::method | Class#method | Class.method | method + + gem_name: | gem_name:README | gem_name:History + +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. + +For example: + + #{opt.program_name} Fil + #{opt.program_name} File + #{opt.program_name} File.new + #{opt.program_name} zip + #{opt.program_name} rdoc:README + +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 ri 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 directly to stdout,", + "rather than to a pager.") 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", + "Uses 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.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, + "Dumps 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] + + # pager process for jruby + @jruby_pager_process = nil + 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] + + break unless stores and not stores.empty? + + klasses = stores.map do |store| + store.ancestors[current] + end.flatten.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| + text = document.accept formatter(io) + + 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 + + ## + # Expands abbreviated klass +klass+ into a fully-qualified class. "Zl::Da" + # will be expanded to Zlib::DataError. + + def expand_class klass + klass.split('::').inject '' do |expanded, klass_part| + expanded << '::' unless expanded.empty? + short = expanded << klass_part + + subset = classes.keys.select do |klass_name| + klass_name =~ /^#{expanded}[^:]*$/ + end + + abbrevs = Abbrev.abbrev subset + + expanded = abbrevs[short] + + raise NotFoundError, short unless expanded + + expanded.dup + end + 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 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 + @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." + + 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? + + name = expand_name name.strip + + begin + display_name name + rescue NotFoundError => e + puts e.message + end + end + + rescue Interrupt + 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 = [] + 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.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 + + raise NotFoundError, name if found.empty? + + 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 + @jruby_pager_process.wait_for if @jruby_pager_process + 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 + render_method_comment out, method + 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 # :nodoc: + out << RDoc::Markup::BlankLine.new + out << method.comment + out << RDoc::Markup::BlankLine.new + 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 + + jruby = Object.const_defined?(:RUBY_ENGINE) && RUBY_ENGINE == 'jruby' + + pagers = [ENV['RI_PAGER'], ENV['PAGER'], 'pager', 'less', 'more'] + + 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 + + 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 + require 'webrick' + + 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 + diff --git a/jni/ruby/lib/rdoc/ri/formatter.rb b/jni/ruby/lib/rdoc/ri/formatter.rb new file mode 100644 index 0000000..84d37a9 --- /dev/null +++ b/jni/ruby/lib/rdoc/ri/formatter.rb @@ -0,0 +1,5 @@ +## +# For RubyGems backwards compatibility + +module RDoc::RI::Formatter # :nodoc: +end diff --git a/jni/ruby/lib/rdoc/ri/paths.rb b/jni/ruby/lib/rdoc/ri/paths.rb new file mode 100644 index 0000000..970cb91 --- /dev/null +++ b/jni/ruby/lib/rdoc/ri/paths.rb @@ -0,0 +1,187 @@ +require 'rdoc/ri' + +## +# The directories where ri data lives. Paths can be enumerated via ::each, or +# queried individually via ::system_dir, ::site_dir, ::home_dir and ::gem_dir. + +module RDoc::RI::Paths + + #:stopdoc: + require 'rbconfig' + + version = RbConfig::CONFIG['ruby_version'] + + BASE = if RbConfig::CONFIG.key? 'ridir' then + File.join RbConfig::CONFIG['ridir'], version + else + File.join RbConfig::CONFIG['datadir'], 'ri', version + end + + homedir = begin + File.expand_path('~') + rescue ArgumentError + end + + homedir ||= ENV['HOME'] || + ENV['USERPROFILE'] || ENV['HOMEPATH'] # for 1.8 compatibility + + HOMEDIR = if homedir then + File.join homedir, ".rdoc" + end + #:startdoc: + + ## + # Iterates over each selected path yielding the directory and type. + # + # Yielded types: + # :system:: Where Ruby's ri data is stored. Yielded when +system+ is + # true + # :site:: Where ri for installed libraries are stored. Yielded when + # +site+ is true. Normally no ri data is stored here. + # :home:: ~/.rdoc. Yielded when +home+ is true. + # :gem:: ri data for an installed gem. Yielded when +gems+ is true. + # :extra:: ri data directory from the command line. Yielded for each + # entry in +extra_dirs+ + + def self.each system = true, site = true, home = true, gems = :latest, *extra_dirs # :yields: directory, type + return enum_for __method__, system, site, home, gems, *extra_dirs unless + block_given? + + extra_dirs.each do |dir| + yield dir, :extra + end + + yield system_dir, :system if system + yield site_dir, :site if site + yield home_dir, :home if home and HOMEDIR + + gemdirs(gems).each do |dir| + yield dir, :gem + end if gems + + nil + end + + ## + # The ri directory for the gem with +gem_name+. + + def self.gem_dir name, version + req = Gem::Requirement.new "= #{version}" + + spec = Gem::Specification.find_by_name name, req + + File.join spec.doc_dir, 'ri' + end + + ## + # The latest installed gems' ri directories. +filter+ can be :all or + # :latest. + # + # A +filter+ :all includes all versions of gems and includes gems without + # ri documentation. + + def self.gemdirs filter = :latest + require 'rubygems' unless defined?(Gem) + + ri_paths = {} + + all = Gem::Specification.map do |spec| + [File.join(spec.doc_dir, 'ri'), spec.name, spec.version] + end + + if filter == :all then + gemdirs = [] + + all.group_by do |_, name, _| + name + end.sort_by do |group, _| + group + end.map do |group, items| + items.sort_by do |_, _, version| + version + end.reverse_each do |dir,| + gemdirs << dir + end + end + + return gemdirs + end + + all.each do |dir, name, ver| + next unless File.exist? dir + + if ri_paths[name].nil? or ver > ri_paths[name].first then + ri_paths[name] = [ver, name, dir] + end + end + + ri_paths.sort_by { |_, (_, name, _)| name }.map { |k, v| v.last } + rescue LoadError + [] + end + + ## + # The location of the rdoc data in the user's home directory. + # + # Like ::system, ri data in the user's home directory is rare and predates + # libraries distributed via RubyGems. ri data is rarely generated into this + # directory. + + def self.home_dir + HOMEDIR + end + + ## + # Returns existing directories from the selected documentation directories + # as an Array. + # + # See also ::each + + def self.path(system = true, site = true, home = true, gems = :latest, *extra_dirs) + path = raw_path system, site, home, gems, *extra_dirs + + path.select { |directory| File.directory? directory } + end + + ## + # Returns selected documentation directories including nonexistent + # directories. + # + # See also ::each + + def self.raw_path(system, site, home, gems, *extra_dirs) + path = [] + + each(system, site, home, gems, *extra_dirs) do |dir, type| + path << dir + end + + path.compact + end + + ## + # The location of ri data installed into the site dir. + # + # Historically this was available for documentation installed by Ruby + # libraries predating RubyGems. It is unlikely to contain any content for + # modern Ruby installations. + + def self.site_dir + File.join BASE, 'site' + end + + ## + # The location of the built-in ri data. + # + # This data is built automatically when `make` is run when Ruby is + # installed. If you did not install Ruby by hand you may need to install + # the documentation yourself. Please consult the documentation for your + # package manager or Ruby installer for details. You can also use the + # rdoc-data gem to install system ri data for common versions of Ruby. + + def self.system_dir + File.join BASE, 'system' + end + +end + diff --git a/jni/ruby/lib/rdoc/ri/store.rb b/jni/ruby/lib/rdoc/ri/store.rb new file mode 100644 index 0000000..9fa9bbb --- /dev/null +++ b/jni/ruby/lib/rdoc/ri/store.rb @@ -0,0 +1,6 @@ +module RDoc::RI + + Store = RDoc::Store # :nodoc: + +end + diff --git a/jni/ruby/lib/rdoc/ri/task.rb b/jni/ruby/lib/rdoc/ri/task.rb new file mode 100644 index 0000000..e545d4a --- /dev/null +++ b/jni/ruby/lib/rdoc/ri/task.rb @@ -0,0 +1,71 @@ +require 'rubygems' +begin + gem 'rdoc' +rescue Gem::LoadError +end unless defined?(RDoc) + +require 'rdoc/task' + +## +# RDoc::RI::Task creates ri data in <code>./.rdoc</code> for your project. +# +# It contains the following tasks: +# +# [ri] +# Build ri data +# +# [clobber_ri] +# Delete ri data files. This target is automatically added to the main +# clobber target. +# +# [reri] +# Rebuild the ri data from scratch even if they are not out of date. +# +# Simple example: +# +# require 'rdoc/ri/task' +# +# RDoc::RI::Task.new do |ri| +# ri.main = 'README.rdoc' +# ri.rdoc_files.include 'README.rdoc', 'lib/**/*.rb' +# end +# +# For further configuration details see RDoc::Task. + +class RDoc::RI::Task < RDoc::Task + + DEFAULT_NAMES = { # :nodoc: + :clobber_rdoc => :clobber_ri, + :rdoc => :ri, + :rerdoc => :reri, + } + + ## + # Create an ri task with the given name. See RDoc::Task for documentation on + # setting names. + + def initialize name = DEFAULT_NAMES # :yield: self + super + end + + def clobber_task_description # :nodoc: + "Remove RI data files" + end + + ## + # Sets default task values + + def defaults + super + + @rdoc_dir = '.rdoc' + end + + def rdoc_task_description # :nodoc: + 'Build RI data files' + end + + def rerdoc_task_description # :nodoc: + 'Rebuild RI data files' + end +end |