rdoc 3.12.2 → 4.0.0.preview2

data/lib/rdoc/ruby_lex.rb

@@ -857,7 +857,7 @@ class RDoc::RubyLex
   end
 
   IDENT_RE = if defined? Encoding then
-               eval '/[\w\u{0080}-\u{FFFFF}]/u' # 1.8 can't parse \u{}
+               /[\w\u0080-\uFFFF]/u
              else
                /[\w\x80-\xFF]/
              end
@@ -982,13 +982,12 @@ class RDoc::RubyLex
       indent = true
     end
     if /['"`]/ =~ ch
-      user_quote = lt = ch
+      lt = ch
       quoted = ""
       while (c = getc) && c != lt
         quoted.concat c
       end
     else
-      user_quote = nil
       lt = '"'
       quoted = ch.dup
       while (c = getc) && c =~ /\w/
@@ -1008,17 +1007,8 @@ class RDoc::RubyLex
       end
     end
 
-    output_heredoc = reserve.join =~ /\A\r?\n\z/
-
-    if output_heredoc then
-      doc = '<<'
-      doc << '-' if indent
-      doc << "#{user_quote}#{quoted}#{user_quote}\n"
-    else
-      doc = '"'
-    end
-
     @here_header = false
+    doc = '"'
     while l = gets
       l = l.sub(/(:?\r)?\n\z/, "\n")
       if (indent ? l.strip : l.chomp) == quoted
@@ -1026,12 +1016,7 @@ class RDoc::RubyLex
       end
       doc << l
     end
-
-    if output_heredoc then
-      doc << l.chomp
-    else
-      doc << '"'
-    end
+    doc << '"'
 
     @here_header = true
     @here_readed.concat reserve
@@ -1039,10 +1024,9 @@ class RDoc::RubyLex
       ungetc ch
     end
 
-    token_class = output_heredoc ? RDoc::RubyLex::TkHEREDOC : Ltype2Token[lt]
     @ltype = ltback
     @lex_state = EXPR_END
-    Token(token_class, doc)
+    Token(Ltype2Token[lt], doc)
   end
 
   def identify_quotation

data/lib/rdoc/ruby_token.rb

@@ -331,7 +331,6 @@ module RDoc::RubyToken
     [:TkINTEGER,    TkVal],
     [:TkFLOAT,      TkVal],
     [:TkSTRING,     TkVal],
-    [:TkHEREDOC,    TkVal],
     [:TkXSTRING,    TkVal],
     [:TkREGEXP,     TkVal],
     [:TkSYMBOL,     TkVal],
@@ -371,13 +370,13 @@ module RDoc::RubyToken
     [:TkfLPAREN,    Token,  "("], # func( #
     [:TkfLBRACK,    Token,  "["], # func[ #
     [:TkfLBRACE,    Token,  "{"], # func{ #
-    [:TkSTAR,       Token,  "*"], # *arg
-    [:TkAMPER,      Token,  "&"], # &arg #
     [:TkSYMBEG,     Token,  ":"], # :SYMBOL
 
+    [:TkAMPER,      TkOp,   "&"],
     [:TkGT,         TkOp,   ">"],
     [:TkLT,         TkOp,   "<"],
     [:TkPLUS,       TkOp,   "+"],
+    [:TkSTAR,       TkOp,   "*"],
     [:TkMINUS,      TkOp,   "-"],
     [:TkMULT,       TkOp,   "*"],
     [:TkDIV,        TkOp,   "/"],

data/lib/rdoc/rubygems_hook.rb

@@ -73,7 +73,6 @@ class RDoc::RubygemsHook
 
   def initialize spec, generate_rdoc = true, generate_ri = true
     @doc_dir   = spec.doc_dir
-    @file_info = nil
     @force     = false
     @rdoc      = nil
     @spec      = spec
@@ -104,23 +103,27 @@ class RDoc::RubygemsHook
   # Documentation will be generated into +destination+
 
   def document generator, options, destination
+    generator_name = generator
+
     options = options.dup
     options.exclude ||= [] # TODO maybe move to RDoc::Options#finish
     options.setup_generator generator
     options.op_dir = destination
     options.finish
 
+    generator = options.generator.new @rdoc.store, options
+
     @rdoc.options = options
-    @rdoc.generator = options.generator.new options
+    @rdoc.generator = generator
 
-    say "Installing #{generator} documentation for #{@spec.full_name}"
+    say "Installing #{generator_name} documentation for #{@spec.full_name}"
 
     FileUtils.mkdir_p options.op_dir
 
     Dir.chdir options.op_dir do
       begin
         @rdoc.class.current = @rdoc
-        @rdoc.generator.generate @file_info
+        @rdoc.generator.generate
       ensure
         @rdoc.class.current = nil
       end
@@ -131,17 +134,16 @@ class RDoc::RubygemsHook
   # Generates RDoc and ri data
 
   def generate
+    return if @spec.default_gem?
     return unless @generate_ri or @generate_rdoc
 
     setup
 
-    ::RDoc::RDoc.reset
-
     options = ::RDoc::Options.new
     options.default_title = "#{@spec.full_name} Documentation"
     options.files = []
-    options.files.push(*@spec.require_paths)
-    options.files.push(*@spec.extra_rdoc_files)
+    options.files.concat @spec.require_paths
+    options.files.concat @spec.extra_rdoc_files
 
     args = @spec.rdoc_options
 
@@ -159,8 +161,18 @@ class RDoc::RubygemsHook
     @rdoc = new_rdoc
     @rdoc.options = options
 
+    store = RDoc::Store.new
+    store.encoding = options.encoding if options.respond_to? :encoding
+    store.dry_run  = options.dry_run
+    store.main     = options.main_page
+    store.title    = options.title
+
+    @rdoc.store = RDoc::Store.new
+
+    say "Parsing documentation for #{@spec.full_name}"
+
     Dir.chdir @spec.full_gem_path do
-      @file_info = @rdoc.parse_files options.files
+      @rdoc.parse_files options.files
     end
 
     document 'ri',       options, @ri_dir if

data/lib/rdoc/servlet.rb

@@ -0,0 +1,302 @@
+require 'rdoc'
+require 'time'
+require 'webrick'
+
+class RDoc::Servlet < WEBrick::HTTPServlet::AbstractServlet
+
+  @server_stores = Hash.new { |hash, server| hash[server] = {} }
+  @cache         = Hash.new { |hash, store|  hash[store]  = {} }
+
+  attr_reader :asset_dirs
+
+  attr_reader :options
+
+  def self.get_instance server, *options
+    stores = @server_stores[server]
+
+    new server, stores, @cache, *options
+  end
+
+  def initialize server, stores, cache, mount_path = nil
+    super server
+
+    @cache      = cache
+    @mount_path = mount_path
+    @stores     = stores
+
+    @options = RDoc::Options.new
+    @options.op_dir = '.'
+
+    darkfish_dir = nil
+
+    # HACK dup
+    $LOAD_PATH.each do |path|
+      darkfish_dir = File.join path, 'rdoc/generator/template/darkfish/'
+      next unless File.directory? darkfish_dir
+      @options.template_dir = darkfish_dir
+      break
+    end
+
+    @asset_dirs = {
+      :darkfish   => darkfish_dir,
+      :json_index =>
+        File.expand_path('../generator/template/json_index/', __FILE__),
+    }
+  end
+
+  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 = File.read asset_path
+
+    res.content_type = case req.path
+                       when /css$/ then 'text/css'
+                       when /js$/  then 'application/javascript'
+                       else             'application/octet-stream'
+                       end
+  end
+
+  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
+    else
+      show_documentation req, res
+    end
+  rescue WEBrick::HTTPStatus::Status
+    raise
+  rescue => e
+    error e, req, res
+  end
+
+  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
+    else
+      not_found generator, req, res
+    end
+  end
+
+  def documentation_search store, generator, req, res
+    json_index = @cache[store].fetch :json_index do
+      @cache[store][:json_index] =
+        JSON.dump generator.json_index.build_index
+    end
+
+    res.content_type = 'application/javascript'
+    res.body = "var search_data = #{json_index}"
+  end
+
+  def documentation_source path
+    _, source_name, path = path.split '/', 3
+
+    store = @stores[source_name]
+    return store, path if store
+
+    store = store_for source_name
+
+    store.load_all
+
+    @stores[source_name] = store
+
+    return store, path
+  end
+
+  def error e, req, res
+    backtrace = e.backtrace.join "\n"
+
+    res.content_type = 'text/html'
+    res.status = 500
+    res.body = <<-BODY
+<!DOCTYPE html>
+<html>
+<head>
+<meta content="text/html; charset=UTF-8" http-equiv="Content-Type">
+
+<title>Error - #{ERB::Util.html_escape e.class}</title>
+
+<link type="text/css" media="screen" href="#{@mount_path}/rdoc.css" rel="stylesheet">
+</head>
+<body>
+<h1>Error</h1>
+
+<p>While processing <code>#{ERB::Util.html_escape req.request_uri}</code> the
+RDoc server has encountered a <code>#{ERB::Util.html_escape e.class}</code>
+exception:
+
+<pre>#{ERB::Util.html_escape e.message}</pre>
+
+<p>Backtrace:
+
+<pre>#{ERB::Util.html_escape backtrace}</pre>
+
+</body>
+</html>
+    BODY
+  end
+
+  def generator_for store
+    generator = RDoc::Generator::Darkfish.new store, @options
+    generator.file_output = false
+    generator.asset_rel_path = '..'
+
+    rdoc = RDoc::RDoc.new
+    rdoc.store     = store
+    rdoc.generator = generator
+    rdoc.options   = @options
+
+    @options.main_page = store.main
+    @options.title     = store.title
+
+    generator
+  end
+
+  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
+    end
+  end
+
+  def installed_docs
+    ri_paths.map do |path, type|
+      store = RDoc::Store.new 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]
+      end
+    end
+  end
+
+  def not_found generator, req, res
+    res.body = generator.generate_servlet_not_found req.path
+    res.status = 404
+  end
+
+  def ri_paths &block
+    RDoc::RI::Paths.each true, true, true, :all, &block
+  end
+
+  def root req, res
+    generator = RDoc::Generator::Darkfish.new nil, @options
+
+    res.body = generator.generate_servlet_root installed_docs
+
+    res.content_type = 'text/html'
+  end
+
+  def root_search req, res
+    search_index = []
+    info         = []
+
+    installed_docs.map do |name, href, exists, type, path|
+      next unless exists
+
+      search_index << name
+
+      comment = case type
+                when :gem
+                  gemspec = path.gsub(%r%/doc/([^/]*?)/ri$%,
+                                      '/specifications/\1.gemspec')
+
+                  spec = Gem::Specification.load gemspec
+
+                  spec.summary
+                when :system then
+                  'Documentation for the Ruby standard library'
+                when :site then
+                  'Documentation for non-gem libraries'
+                when :home then
+                  'Documentation from your home directory'
+                end
+
+      info << [name, '', path, '', comment]
+    end
+
+    index = {
+      :index => {
+        :searchIndex     => search_index,
+        :longSearchIndex => search_index,
+        :info            => info,
+      }
+    }
+
+    res.body = "var search_data = #{JSON.dump index};"
+    res.content_type = 'application/javascript'
+  end
+
+  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
+    else
+      documentation_page store, generator, path, req, res
+    end
+  ensure
+    res.content_type ||= 'text/html'
+  end
+
+  def store_for source_name
+    case source_name
+    when 'ruby' then
+      RDoc::Store.new RDoc::RI::Paths.system_dir, :system
+    else
+      ri_dir, type = ri_paths.find do |dir, dir_type|
+        next unless dir_type == :gem
+
+        source_name == dir[%r%/([^/]*)/ri$%, 1]
+      end
+
+      raise "could not find ri documentation for #{source_name}" unless
+        ri_dir
+
+      RDoc::Store.new ri_dir, type
+    end
+  end
+
+end
+