class RDoc::Servlet

This is a WEBrick servlet that allows you to browse ri documentation.

You can show documentation through either `ri –server` or, with RubyGems 2.0 or newer, `gem server`. For ri, the server runs on port 8214 by default. For RubyGems the server runs on port 8808 by default.

You can use this servlet in your own project by mounting it on a WEBrick server:

require 'webrick'

server = Port: 8000

server.mount '/', RDoc::Servlet

If you want to mount the servlet some other place than the root, provide the base path when mounting:

server.mount '/rdoc', RDoc::Servlet, '/rdoc'



Maps an asset type to its path on the filesystem


An RDoc::Options instance used for rendering options

Public Class Methods

new(server, stores, cache, mount_path = nil) click to toggle source

Creates a new WEBrick servlet.

Use mount_path when mounting the servlet somewhere other than /.

server is provided automatically by WEBrick when mounting. stores and cache are provided automatically by the servlet.

# File lib/rdoc/servlet.rb, line 59
def initialize server, stores, cache, mount_path = nil
  super server

  @cache      = cache
  @mount_path = mount_path
  @stores     = stores

  @options =
  @options.op_dir = '.'

  darkfish_dir = nil

  # HACK dup
  $LOAD_PATH.each do |path|
    darkfish_dir = File.join path, 'rdoc/generator/template/darkfish/'
    next unless darkfish_dir
    @options.template_dir = darkfish_dir

  @asset_dirs = {
    :darkfish   => darkfish_dir,
    :json_index =>
      File.expand_path('../generator/template/json_index/', __FILE__),

Public Instance Methods

asset(generator_name, req, res) click to toggle source

Serves the asset at the path in req for generator_name via res.

# File lib/rdoc/servlet.rb, line 89
def asset generator_name, req, res
  asset_dir = @asset_dirs[generator_name]

  asset_path = File.join asset_dir, req.path

  if_modified_since req, res, asset_path

  res.body = asset_path

  res.content_type = case req.path
                     when /css$/ then 'text/css'
                     when /js$/  then 'application/javascript'
                     else             'application/octet-stream'
do_GET(req, res) click to toggle source

GET request entry point. Fills in res for the path, etc. in req.

# File lib/rdoc/servlet.rb, line 108
def do_GET req, res
  req.path.sub!(/^#{Regexp.escape @mount_path}/o, '') if @mount_path

  case req.path
  when '/' then
    root req, res
  when '/rdoc.css', '/js/darkfish.js', '/js/jquery.js', '/js/search.js',
       %r%^/images/% then
    asset :darkfish, req, res
  when '/js/navigation.js', '/js/searcher.js' then
    asset :json_index, req, res
  when '/js/search_index.js' then
    root_search req, res
    show_documentation req, res
rescue WEBrick::HTTPStatus::Status
rescue => e
  error e, req, res
documentation_page(store, generator, path, req, res) click to toggle source

Fills in res with the class, module or page for req from store.

path is relative to the mount_path and is used to determine the class, module or page name (/RDoc/Servlet.html becomes RDoc::Servlet). generator is used to create the page.

# File lib/rdoc/servlet.rb, line 137
def documentation_page store, generator, path, req, res
  name = path.sub(/.html$/, '').gsub '/', '::'

  if klass = store.find_class_or_module(name) then
    res.body = generator.generate_class klass
  elsif page = store.find_text_page(name.sub(/_([^_]*)$/, '.\1')) then
    res.body = generator.generate_page page
    not_found generator, req, res
documentation_source(path) click to toggle source

Returns the RDoc::Store and path relative to mount_path for documentation at path.

# File lib/rdoc/servlet.rb, line 167
def documentation_source path
  _, source_name, path = path.split '/', 3

  store = @stores[source_name]
  return store, path if store

  store = store_for source_name


  @stores[source_name] = store

  return store, path
error(exception, req, res) click to toggle source

Generates an error page for the exception while handling req on res.

# File lib/rdoc/servlet.rb, line 185
  def error exception, req, res
    backtrace = exception.backtrace.join "\n"

    res.content_type = 'text/html'
    res.status = 500
    res.body = <<-BODY
<!DOCTYPE html>
<meta content="text/html; charset=UTF-8" http-equiv="Content-Type">

<title>Error - #{ERB::Util.html_escape exception.class}</title>

<link type="text/css" media="screen" href="#{@mount_path}/rdoc.css" rel="stylesheet">

<p>While processing <code>#{ERB::Util.html_escape req.request_uri}</code> the
RDoc (#{ERB::Util.html_escape RDoc::VERSION}) server has encountered a
<code>#{ERB::Util.html_escape exception.class}</code>

<pre>#{ERB::Util.html_escape exception.message}</pre>

<p>Please report this to the
<a href="">RDoc issues tracker</a>.  Please
include the RDoc version, the URI above and exception class, message and
backtrace.  If you're viewing a gem's documentation, include the gem name and
version.  If you're viewing Ruby's documentation, include the version of ruby.


<pre>#{ERB::Util.html_escape backtrace}</pre>

generator_for(store) click to toggle source

Instantiates a Darkfish generator for store

# File lib/rdoc/servlet.rb, line 228
def generator_for store
  generator = store, @options
  generator.file_output = false
  generator.asset_rel_path = '..'

  rdoc =     = store
  rdoc.generator = generator
  rdoc.options   = @options

  @options.main_page = store.main
  @options.title     = store.title

if_modified_since(req, res, path = nil) click to toggle source

Handles the If-Modified-Since HTTP header on req for path. If the file has not been modified a Not Modified response is returned. If the file has been modified a Last-Modified header is added to res.

# File lib/rdoc/servlet.rb, line 249
def if_modified_since req, res, path = nil
  last_modified = File.stat(path).mtime if path

  res['last-modified'] = last_modified.httpdate

  return unless ims = req['if-modified-since']

  ims = Time.parse ims

  unless ims < last_modified then
    res.body = ''
    raise WEBrick::HTTPStatus::NotModified
installed_docs() click to toggle source

Returns an Array of installed documentation.

Each entry contains the documentation name (gem name, 'Ruby Documentation', etc.), the path relative to the mount point, whether the documentation exists, the type of documentation (See RDoc::RI::Paths#each) and the filesystem to the RDoc::Store for the documentation.

# File lib/rdoc/servlet.rb, line 272
def installed_docs do |path, type|
    store = path, type
    exists = File.exist? store.cache_path

    case type
    when :gem then
      gem_path = path[%r%/([^/]*)/ri$%, 1]
      [gem_path, "#{gem_path}/", exists, type, path]
    when :system then
      ['Ruby Documentation', 'ruby/', exists, type, path]
    when :site then
      ['Site Documentation', 'site/', exists, type, path]
    when :home then
      ['Home Documentation', 'home/', exists, type, path]
not_found(generator, req, res) click to toggle source

Returns a 404 page built by generator for req on res.

# File lib/rdoc/servlet.rb, line 294
def not_found generator, req, res
  res.body = generator.generate_servlet_not_found req.path
  res.status = 404
ri_paths(&block) click to toggle source

Enumerates the ri paths. See RDoc::RI::Paths#each

# File lib/rdoc/servlet.rb, line 302
def ri_paths &block
  RDoc::RI::Paths.each true, true, true, :all, &block
root(req, res) click to toggle source

Generates the root page on res. req is ignored.

# File lib/rdoc/servlet.rb, line 309
def root req, res
  generator = nil, @options

  res.body = generator.generate_servlet_root installed_docs

  res.content_type = 'text/html'
show_documentation(req, res) click to toggle source

Displays documentation for req on res, whether that be HTML or some asset.

# File lib/rdoc/servlet.rb, line 368
def show_documentation req, res
  store, path = documentation_source req.path

  if_modified_since req, res, store.cache_path

  generator = generator_for store

  case path
  when nil, '', 'index.html' then
    res.body = generator.generate_index
  when 'table_of_contents.html' then
    res.body = generator.generate_table_of_contents
  when 'js/search_index.js' then
    documentation_search store, generator, req, res
    documentation_page store, generator, path, req, res
  res.content_type ||= 'text/html'
store_for(source_name) click to toggle source

Returns an RDoc::Store for the given source_name ('ruby' or a gem name).

# File lib/rdoc/servlet.rb, line 392
def store_for source_name
  case source_name
  when 'home' then RDoc::RI::Paths.home_dir, :home
  when 'ruby' then RDoc::RI::Paths.system_dir, :system
  when 'site' then RDoc::RI::Paths.site_dir, :site
    ri_dir, type = ri_paths.find do |dir, dir_type|
      next unless dir_type == :gem

      source_name == dir[%r%/([^/]*)/ri$%, 1]

    raise RDoc::Error,
          "could not find ri documentation for #{source_name}" unless
      ri_dir ri_dir, type