super-quick-rb 0.0.1

data/rdoc-8.0.0/lib/rdoc/ri/formatter.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+##
+# For RubyGems backwards compatibility
+
+module RDoc::RI::Formatter # :nodoc:
+end

data/rdoc-8.0.0/lib/rdoc/ri/paths.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+require_relative '../rdoc'
+
+##
+# 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    = File.join RbConfig::CONFIG['ridir'], version
+
+  HOMEDIR = RDoc.home
+  #: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)
+    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

data/rdoc-8.0.0/lib/rdoc/ri/servlet.rb

@@ -0,0 +1,452 @@
+# frozen_string_literal: true
+require_relative '../../rdoc'
+require 'erb'
+require 'time'
+require 'json'
+
+begin
+  require 'webrick'
+rescue LoadError
+  abort "webrick is not found. You may need to `gem install webrick` to install webrick."
+end
+
+##
+# 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 = WEBrick::HTTPServer.new Port: 8000
+#
+#   server.mount '/', RDoc::RI::Servlet
+#
+# If you want to mount the servlet some other place than the root, provide the
+# base path when mounting:
+#
+#   server.mount '/rdoc', RDoc::RI::Servlet, '/rdoc'
+
+class RDoc::RI::Servlet < WEBrick::HTTPServlet::AbstractServlet
+
+  @server_stores = Hash.new { |hash, server| hash[server] = {} }
+  @cache         = Hash.new { |hash, store|  hash[store]  = {} }
+
+  ##
+  # Maps an asset type to its path on the filesystem
+
+  attr_reader :asset_dirs
+
+  ##
+  # An RDoc::Options instance used for rendering options
+
+  attr_reader :options
+
+  ##
+  # Creates an instance of this servlet that shares cached data between
+  # requests.
+
+  def self.get_instance(server, *options) # :nodoc:
+    stores = @server_stores[server]
+
+    new server, stores, @cache, *options
+  end
+
+  ##
+  # Creates a new WEBrick servlet.
+  #
+  # Use +mount_path+ when mounting the servlet somewhere other than /.
+  #
+  # Use +extra_doc_dirs+ for additional documentation directories.
+  #
+  # +server+ is provided automatically by WEBrick when mounting.  +stores+ and
+  # +cache+ are provided automatically by the servlet.
+
+  def initialize(server, stores, cache, mount_path = nil, extra_doc_dirs = [])
+    super server
+
+    @cache      = cache
+    @mount_path = mount_path
+    @extra_doc_dirs = extra_doc_dirs
+    @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
+
+  ##
+  # Serves the asset at the path in +req+ for +generator_name+ via +res+.
+
+  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\z/ then 'text/css'
+                       when /\.js\z/  then 'application/javascript'
+                       else                'application/octet-stream'
+                       end
+  end
+
+  ##
+  # GET request entry point.  Fills in +res+ for the path, etc. in +req+.
+
+  def do_GET(req, res)
+    req.path.sub!(/\A#{Regexp.escape @mount_path}/, '') if @mount_path
+
+    case req.path
+    when '/' then
+      root req, res
+    when '/js/darkfish.js', '/js/jquery.js', '/js/search.js',
+         %r%^/css/%, %r%^/images/%, %r%^/fonts/% 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::NotFound => e
+    generator = generator_for RDoc::Store.new(@options)
+
+    not_found generator, req, res, e.message
+  rescue WEBrick::HTTPStatus::Status
+    raise
+  rescue => e
+    error e, req, res
+  end
+
+  ##
+  # 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.
+
+  def documentation_page(store, generator, path, req, res)
+    text_name = path.chomp '.html'
+    name = text_name.gsub '/', '::'
+
+    if klass = store.find_class_or_module(name) then
+      res.body = generator.generate_class klass
+    elsif page = store.find_text_page(name.sub(/_([^_]*)\z/, '.\1')) then
+      res.body = generator.generate_page page
+    elsif page = store.find_text_page(text_name.sub(/_([^_]*)\z/, '.\1')) then
+      res.body = generator.generate_page page
+    else
+      not_found generator, req, res
+    end
+  end
+
+  ##
+  # Creates the JSON search index on +res+ for the given +store+.  +generator+
+  # must respond to \#json_index to build.  +req+ is ignored.
+
+  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
+
+  ##
+  # Returns the RDoc::Store and path relative to +mount_path+ for
+  # documentation at +path+.
+
+  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
+
+  ##
+  # Generates an error page for the +exception+ while handling +req+ on +res+.
+
+  def error(exception, req, res)
+    backtrace = exception.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 exception.class}</title>
+
+<link type="text/css" media="screen" href="#{@mount_path}/css/rdoc.css" rel="stylesheet">
+</head>
+<body>
+<h1>Error</h1>
+
+<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>
+exception:
+
+<pre>#{ERB::Util.html_escape exception.message}</pre>
+
+<p>Please report this to the
+<a href="https://github.com/ruby/rdoc/issues">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.
+
+<p>Backtrace:
+
+<pre>#{ERB::Util.html_escape backtrace}</pre>
+
+</body>
+</html>
+    BODY
+  end
+
+  ##
+  # Instantiates a Darkfish generator for +store+
+
+  def generator_for(store)
+    generator = RDoc::Generator::Darkfish.new store, @options
+    generator.file_output = false
+    generator.asset_rel_path = '..'
+    generator.setup
+
+    rdoc = RDoc::RDoc.new
+    rdoc.store     = store
+    rdoc.generator = generator
+    rdoc.options   = @options
+
+    @options.main_page = store.main
+    @options.title     = store.title
+
+    generator
+  end
+
+  ##
+  # 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+.
+
+  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
+
+  ##
+  # 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.
+
+  def installed_docs
+    extra_counter = 0
+    ri_paths.map do |path, type|
+      store = RDoc::Store.new(@options, path: path, type: 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]
+      when :extra then
+        extra_counter += 1
+        store.load_cache if exists
+        title = store.title || "Extra Documentation"
+        [title, "extra-#{extra_counter}/", exists, type, path]
+      end
+    end
+  end
+
+  ##
+  # Returns a 404 page built by +generator+ for +req+ on +res+.
+
+  def not_found(generator, req, res, message = nil)
+    message ||= "The page <kbd>#{ERB::Util.h req.path}</kbd> was not found"
+    res.body = generator.generate_servlet_not_found message
+    res.status = 404
+  end
+
+  ##
+  # Enumerates the ri paths.  See RDoc::RI::Paths#each
+
+  def ri_paths(&block)
+    RDoc::RI::Paths.each true, true, true, :all, *@extra_doc_dirs, &block #TODO: pass extra_dirs
+  end
+
+  ##
+  # Generates the root page on +res+.  +req+ is ignored.
+
+  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
+
+  ##
+  # Generates a search index for the root page on +res+.  +req+ is ignored.
+
+  def root_search(req, res)
+    search_index = []
+    info         = []
+
+    installed_docs.map do |name, href, exists, type, path|
+      next unless exists
+
+      search_index << name
+
+      case type
+      when :gem
+        gemspec = path.gsub(%r%/doc/([^/]*?)/ri$%,
+                            '/specifications/\1.gemspec')
+
+        spec = Gem::Specification.load gemspec
+
+        path    = spec.full_name
+        comment = spec.summary
+      when :system then
+        path    = 'ruby'
+        comment = 'Documentation for the Ruby standard library'
+      when :site then
+        path    = 'site'
+        comment = 'Documentation for non-gem libraries'
+      when :home then
+        path    = 'home'
+        comment = 'Documentation from your home directory'
+      when :extra
+        comment = name
+      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
+
+  ##
+  # Displays documentation for +req+ on +res+, whether that be HTML or some
+  # asset.
+
+  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
+
+  ##
+  # Returns an RDoc::Store for the given +source_name+ ('ruby' or a gem name).
+
+  def store_for(source_name)
+    case source_name
+    when 'home' then
+      RDoc::Store.new(@options, path: RDoc::RI::Paths.home_dir, type: :home)
+    when 'ruby' then
+      RDoc::Store.new(@options, path: RDoc::RI::Paths.system_dir, type: :system)
+    when 'site' then
+      RDoc::Store.new(@options, path: RDoc::RI::Paths.site_dir, type: :site)
+    when /\Aextra-(\d+)\z/ then
+      index = $1.to_i - 1
+      ri_dir = installed_docs[index][4]
+      RDoc::Store.new(@options, path: ri_dir, type: :extra)
+    else
+      ri_dir, type = ri_paths.find do |dir, dir_type|
+        next unless dir_type == :gem
+
+        source_name == dir[%r%/([^/]*)/ri$%, 1]
+      end
+
+      raise WEBrick::HTTPStatus::NotFound,
+            "Could not find gem \"#{ERB::Util.html_escape(source_name)}\". Are you sure you installed it?" unless ri_dir
+
+      store = RDoc::Store.new(@options, path: ri_dir, type: type)
+
+      return store if File.exist? store.cache_path
+
+      raise WEBrick::HTTPStatus::NotFound,
+            "Could not find documentation for \"#{ERB::Util.html_escape(source_name)}\". Please run `gem rdoc --ri gem_name`"
+
+    end
+  end
+
+end

data/rdoc-8.0.0/lib/rdoc/ri/store.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module RDoc::RI
+
+  Store = RDoc::Store # :nodoc:
+
+end

data/rdoc-8.0.0/lib/rdoc/ri/task.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+begin
+  gem 'rdoc'
+rescue Gem::LoadError
+end unless defined?(RDoc)
+
+require_relative '../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.md'
+#     ri.rdoc_files.include 'README.md', '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