rdoc 2.4.3 → 2.5

data/lib/rdoc/ri/reader.rb

@@ -1,106 +0,0 @@
-require 'rdoc/ri'
-require 'rdoc/ri/descriptions'
-require 'rdoc/ri/writer'
-require 'rdoc/markup/to_flow'
-
-class RDoc::RI::Reader
-
-  def initialize(ri_cache)
-    @cache = ri_cache
-  end
-
-  def top_level_namespace
-    [ @cache.toplevel ]
-  end
-
-  def lookup_namespace_in(target, namespaces)
-    result = []
-    for n in namespaces
-      result.concat(n.contained_modules_matching(target))
-    end
-    result
-  end
-
-  def find_class_by_name(full_name)
-    names = full_name.split(/::/)
-    ns = @cache.toplevel
-    for name in names
-      ns = ns.contained_class_named(name)
-      return nil if ns.nil?
-    end
-    get_class(ns)
-  end
-
-  def find_methods(name, is_class_method, namespaces)
-    result = []
-    namespaces.each do |ns|
-      result.concat ns.methods_matching(name, is_class_method)
-    end
-    result
-  end
-
-  ##
-  # Return the MethodDescription for a given MethodEntry by deserializing the
-  # YAML
-
-  def get_method(method_entry)
-    path = method_entry.path_name
-    File.open(path) { |f| RDoc::RI::Description.deserialize(f) }
-  end
-
-  ##
-  # Return a class description
-
-  def get_class(class_entry)
-    result = nil
-    for path in class_entry.path_names
-      path = RDoc::RI::Writer.class_desc_path(path, class_entry)
-      desc = File.open(path) {|f| RDoc::RI::Description.deserialize(f) }
-      if result
-        result.merge_in(desc)
-      else
-        result = desc
-      end
-    end
-    result
-  end
-
-  ##
-  # Return the names of all classes and modules
-
-  def full_class_names
-    res = []
-    find_classes_in(res, @cache.toplevel)
-  end
-
-  ##
-  # Return a list of all classes, modules, and methods
-
-  def all_names
-    res = []
-    find_names_in(res, @cache.toplevel)
-  end
-
-  private
-
-  def find_classes_in(res, klass)
-    classes = klass.classes_and_modules
-    for c in classes
-      res << c.full_name
-      find_classes_in(res, c)
-    end
-    res
-  end
-
-  def find_names_in(res, klass)
-    classes = klass.classes_and_modules
-    for c in classes
-      res << c.full_name
-      res.concat c.all_method_names
-      find_names_in(res, c)
-    end
-    res
-  end
-
-end
-

data/lib/rdoc/ri/util.rb

@@ -1,79 +0,0 @@
-require 'rdoc/ri'
-
-##
-# Break argument into its constituent class or module names, an
-# optional method type, and a method name
-
-class RDoc::RI::NameDescriptor
-
-  attr_reader :class_names
-  attr_reader :method_name
-
-  ##
-  # true and false have the obvious meaning. nil means we don't care
-
-  attr_reader :is_class_method
-
-  ##
-  # +arg+ may be
-  #
-  # 1. A class or module name (optionally qualified with other class or module
-  #    names (Kernel, File::Stat etc)
-  # 2. A method name
-  # 3. A method name qualified by a optionally fully qualified class or module
-  #    name
-  #
-  # We're fairly casual about delimiters: folks can say Kernel::puts,
-  # Kernel.puts, or Kernel\#puts for example. There's one exception: if you
-  # say IO::read, we look for a class method, but if you say IO.read, we look
-  # for an instance method
-
-  def initialize(arg)
-    @class_names = []
-    separator = nil
-
-    tokens = arg.split(/(\.|::|#)/)
-
-    # Skip leading '::', '#' or '.', but remember it might
-    # be a method name qualifier
-    separator = tokens.shift if tokens[0] =~ /^(\.|::|#)/
-
-    # Skip leading '::', but remember we potentially have an inst
-
-    # leading stuff must be class names
-
-    while tokens[0] =~ /^[A-Z]/
-      @class_names << tokens.shift
-      unless tokens.empty?
-        separator = tokens.shift
-        break unless separator == "::"
-      end
-    end
-
-    # Now must have a single token, the method name, or an empty array
-    unless tokens.empty?
-      @method_name = tokens.shift
-      # We may now have a trailing !, ?, or = to roll into
-      # the method name
-      if !tokens.empty? && tokens[0] =~ /^[!?=]$/
-        @method_name << tokens.shift
-      end
-
-      if @method_name =~ /::|\.|#/ or !tokens.empty?
-        raise RDoc::RI::Error.new("Bad argument: #{arg}") 
-      end
-      if separator && separator != '.'
-        @is_class_method = separator == "::"
-      end
-    end
-  end
-
-  # Return the full class name (with '::' between the components) or "" if
-  # there's no class name
-
-  def full_class_name
-    @class_names.join("::")
-  end
-
-end
-

data/lib/rdoc/ri/writer.rb

@@ -1,68 +0,0 @@
-require 'fileutils'
-require 'rdoc/ri'
-
-class RDoc::RI::Writer
-
-  def self.class_desc_path(dir, class_desc)
-    File.join(dir, "cdesc-" + class_desc.name + ".yaml")
-  end
-
-  ##
-  # Convert a name from internal form (containing punctuation) to an external
-  # form (where punctuation is replaced by %xx)
-
-  def self.internal_to_external(name)
-    if ''.respond_to? :ord then
-      name.gsub(/\W/) { "%%%02x" % $&[0].ord }
-    else
-      name.gsub(/\W/) { "%%%02x" % $&[0] }
-    end
-  end
-
-  ##
-  # And the reverse operation
-
-  def self.external_to_internal(name)
-    name.gsub(/%([0-9a-f]{2,2})/) { $1.to_i(16).chr }
-  end
-
-  def initialize(base_dir)
-    @base_dir = base_dir
-  end
-
-  def remove_class(class_desc)
-    FileUtils.rm_rf(path_to_dir(class_desc.full_name))
-  end
-
-  def add_class(class_desc)
-    dir = path_to_dir(class_desc.full_name)
-    FileUtils.mkdir_p(dir)
-    class_file_name = self.class.class_desc_path(dir, class_desc)
-    File.open(class_file_name, "w") do |f|
-      f.write(class_desc.serialize)
-    end
-  end
-
-  def add_method(class_desc, method_desc)
-    dir = path_to_dir(class_desc.full_name)
-    file_name = self.class.internal_to_external(method_desc.name)
-    meth_file_name = File.join(dir, file_name)
-    if method_desc.is_singleton
-      meth_file_name += "-c.yaml"
-    else
-      meth_file_name += "-i.yaml"
-    end
-
-    File.open(meth_file_name, "w") do |f|
-      f.write(method_desc.serialize)
-    end
-  end
-
-  private
-
-  def path_to_dir(class_name)
-    File.join(@base_dir, *class_name.split('::'))
-  end
-
-end
-

data/test/test_rdoc_ri_attribute_formatter.rb

@@ -1,44 +0,0 @@
-require 'stringio'
-require 'rubygems'
-require 'minitest/unit'
-require 'rdoc/ri/formatter'
-
-class TestRDocRIAttributeFormatter < MiniTest::Unit::TestCase
-
-  def setup
-    @output = StringIO.new
-    @width = 78
-    @indent = '  '
-
-    @f = RDoc::RI::AttributeFormatter.new @output, @width, @indent
-  end
-
-  def test_wrap_empty
-    @f.wrap ''
-    assert_equal '', @output.string
-  end
-
-  def test_wrap_long
-    @f.wrap 'a ' * (@width / 2)
-    assert_equal "  a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a \n  a \n",
-                 @output.string
-  end
-
-  def test_wrap_markup
-    @f.wrap 'a <tt>b</tt> c'
-    assert_equal "  a b c\n", @output.string
-  end
-
-  def test_wrap_nil
-    @f.wrap nil
-    assert_equal '', @output.string
-  end
-
-  def test_wrap_short
-    @f.wrap 'a b c'
-    assert_equal "  a b c\n", @output.string
-  end
-
-end
-
-MiniTest::Unit.autorun

data/test/test_rdoc_ri_default_display.rb

@@ -1,302 +0,0 @@
-require 'stringio'
-require 'rubygems'
-require 'minitest/unit'
-require 'rdoc/ri/formatter'
-require 'rdoc/ri/display'
-require 'rdoc/ri/driver'
-
-class TestRDocRiDefaultDisplay < MiniTest::Unit::TestCase
-
-  def setup
-    @output = StringIO.new
-    @width = 78
-    @indent = '  '
-
-    @dd = RDoc::RI::DefaultDisplay.new RDoc::RI::Formatter, @width, true,
-                                       @output
-
-    @some_method = h \
-      'aliases' => [{'name' => 'some_method_alias'}],
-      'block_params' => 'block_param',
-      'comment' => [RDoc::Markup::Flow::P.new('some comment')],
-      'full_name' => 'SomeClass#some_method',
-      'is_singleton' => false,
-      'name' => 'some_method',
-      'params' => '(arg1, arg2) {|block_param| ...}',
-      'source_path' => '/nonexistent',
-      'visibility' => 'public'
-  end
-
-  def test_display_class_info
-    klass = h \
-      'attributes' => [
-        { 'name' => 'attribute', 'rw' => 'RW',
-          'comment' => [RDoc::Markup::Flow::P.new('attribute comment')] },
-        { 'name' => 'attribute_no_comment', 'rw' => 'RW',
-          'comment' => nil },
-      ],
-      'class_methods' => [
-        { 'name' => 'class_method' },
-      ],
-      'class_method_extensions' => [
-        { 'name' => 'class_method_extension' },
-      ],
-      'comment' => [RDoc::Markup::Flow::P.new('SomeClass comment')],
-      'constants' => [
-        { 'name' => 'CONSTANT', 'value' => '"value1"',
-          'comment' => [RDoc::Markup::Flow::P.new('CONSTANT value')] },
-        { 'name' => 'CONSTANT_NOCOMMENT', 'value' => '"value2"',
-          'comment' => nil },
-      ],
-      'display_name' => 'Class',
-      'full_name' => 'SomeClass',
-      'includes' => [],
-      'instance_methods' => [
-        { 'name' => 'instance_method' },
-        { 'name' => 'instance_method2' },
-      ],
-      'instance_method_extensions' => [
-        { 'name' => 'instance_method_extension' },
-      ],
-      'superclass' => 'Object'
-
-    @dd.display_class_info klass
-
-    expected = <<-EOF
----------------------------------------------------- Class: SomeClass < Object
-     SomeClass comment
-
-------------------------------------------------------------------------------
-
-
-Constants:
-----------
-
-     CONSTANT = "value1"
-          CONSTANT value
-
-     CONSTANT_NOCOMMENT = "value2"
-
-
-Attributes:
------------
-
-     attribute (RW):
-          attribute comment
-
-     attribute_no_comment (RW)
-
-
-Class methods:
---------------
-
-     class_method
-
-
-Class method extensions:
-------------------------
-
-     class_method_extension
-
-
-Instance methods:
------------------
-
-     instance_method, instance_method2
-
-
-Instance method extensions:
----------------------------
-
-     instance_method_extension
-    EOF
-
-    assert_equal expected, @output.string
-  end
-
-  def test_display_flow
-    flow = [RDoc::Markup::Flow::P.new('flow')]
-
-    @dd.display_flow flow
-
-    assert_equal "     flow\n\n", @output.string
-  end
-
-  def test_display_flow_empty
-    @dd.display_flow []
-
-    assert_equal "     [no description]\n", @output.string
-  end
-
-  def test_display_flow_nil
-    @dd.display_flow nil
-
-    assert_equal "     [no description]\n", @output.string
-  end
-
-  def test_display_method_info
-    @dd.display_method_info @some_method
-
-    expected = <<-EOF
--------------------------------------------------------- SomeClass#some_method
-     some_method(arg1, arg2) {|block_param| ...}
-
-     From /nonexistent
-------------------------------------------------------------------------------
-     some comment
-
-
-     (also known as some_method_alias)
-    EOF
-
-    assert_equal expected, @output.string
-  end
-
-  def test_display_method_info_singleton
-    method = RDoc::RI::Driver::OpenStructHash.new.update \
-      'aliases' => [],
-      'block_params' => nil,
-      'comment' => nil,
-      'full_name' => 'SomeClass::some_method',
-      'is_singleton' => true,
-      'name' => 'some_method',
-      'params' => '(arg1, arg2)',
-      'visibility' => 'public'
-
-    @dd.display_method_info method
-
-    expected = <<-EOF
-------------------------------------------------------- SomeClass::some_method
-     SomeClass::some_method(arg1, arg2)
-
-     From 
-------------------------------------------------------------------------------
-     [no description]
-    EOF
-
-    assert_equal expected, @output.string
-  end
-
-  def test_display_method_list
-    methods = [
-      RDoc::RI::Driver::OpenStructHash.new.update(
-        "aliases" => [],
-        "block_params" => nil,
-        "comment" =>  nil,
-        "full_name" => "SomeClass#some_method",
-        "is_singleton" => false,
-        "name" => "some_method",
-        "params" => "()",
-        "visibility" => "public"
-      ),
-      RDoc::RI::Driver::OpenStructHash.new.update(
-        "aliases" => [],
-        "block_params" => nil,
-        "comment" => nil,
-        "full_name" => "SomeClass#some_other_method",
-        "is_singleton" => false,
-        "name" => "some_other_method",
-        "params" => "()",
-        "visibility" => "public"
-      ),
-    ]
-
-    @dd.display_method_list methods
-
-    expected = <<-EOF
-     More than one method matched your request.  You can refine your search by
-     asking for information on one of:
-
-SomeClass#some_method []
-SomeClass#some_other_method []
-    EOF
-
-    assert_equal expected, @output.string
-  end
-
-  def test_display_params
-    @dd.display_params @some_method
-
-    expected = <<-EOF
-     some_method(arg1, arg2) {|block_param| ...}
-
-     From /nonexistent
-    EOF
-
-    assert_equal expected, @output.string
-  end
-
-  def test_display_params_multiple
-    @some_method['params'] = <<-EOF
-some_method(index)
-some_method(start, length)
-    EOF
-
-    @dd.display_params @some_method
-
-    expected = <<-EOF
-     some_method(index)
-     some_method(start, length)
-
-     From /nonexistent
-    EOF
-
-    assert_equal expected, @output.string
-  end
-
-  def test_display_params_singleton
-    @some_method['is_singleton'] = true
-    @some_method['full_name'] = 'SomeClass::some_method'
-
-    @dd.display_params @some_method
-
-    expected = <<-EOF
-     SomeClass::some_method(arg1, arg2) {|block_param| ...}
-
-     From /nonexistent
-    EOF
-
-    assert_equal expected, @output.string
-  end
-
-  def test_list_known_classes
-    klasses = %w[SomeClass SomeModule]
-
-    @dd.list_known_classes klasses
-
-    expected = <<-EOF
----------------------------------------------------- Known classes and modules
-
-     SomeClass
-     SomeModule
-    EOF
-
-    assert_equal expected, @output.string
-  end
-
-  def test_list_known_classes_empty
-    @dd.list_known_classes []
-
-    expected = <<-EOF
-No ri data found
-
-If you've installed Ruby yourself, you need to generate documentation using:
-
-  make install-doc
-
-from the same place you ran `make` to build ruby.
-
-If you installed Ruby from a packaging system, then you may need to
-install an additional package, or ask the packager to enable ri generation.
-    EOF
-
-    assert_equal expected, @output.string
-  end
-
-  def h(hash)
-    RDoc::RI::Driver::OpenStructHash.convert hash
-  end
-
-end
-
-MiniTest::Unit.autorun