rdoc 3.1 → 6.3.3

data/test/test_rdoc_ri_paths.rb

@@ -1,43 +0,0 @@
-require 'rubygems'
-require 'minitest/autorun'
-require 'tmpdir'
-require 'fileutils'
-require 'rdoc/ri/paths'
-
-class TestRDocRIPaths < MiniTest::Unit::TestCase
-
-  def setup
-    RDoc::RI::Paths.instance_variable_set :@gemdirs, %w[/nonexistent/gemdir]
-  end
-
-  def teardown
-    RDoc::RI::Paths.instance_variable_set :@gemdirs, nil
-  end
-
-  def test_class_path_nonexistent
-    path = RDoc::RI::Paths.path true, true, true, true, '/nonexistent'
-
-    refute_includes path, '/nonexistent'
-  end
-
-  def test_class_raw_path
-    path = RDoc::RI::Paths.raw_path true, true, true, true
-
-    assert_equal RDoc::RI::Paths::SYSDIR,  path.shift
-    assert_equal RDoc::RI::Paths::SITEDIR, path.shift
-    assert_equal RDoc::RI::Paths::HOMEDIR, path.shift
-    assert_equal '/nonexistent/gemdir',    path.shift
-  end
-
-  def test_class_raw_path_extra_dirs
-    path = RDoc::RI::Paths.raw_path true, true, true, true, '/nonexistent'
-
-    assert_equal '/nonexistent',           path.shift
-    assert_equal RDoc::RI::Paths::SYSDIR,  path.shift
-    assert_equal RDoc::RI::Paths::SITEDIR, path.shift
-    assert_equal RDoc::RI::Paths::HOMEDIR, path.shift
-    assert_equal '/nonexistent/gemdir',    path.shift
-  end
-
-end
-

data/test/test_rdoc_ri_store.rb

@@ -1,352 +0,0 @@
-require 'rubygems'
-require 'minitest/autorun'
-require 'rdoc/ri'
-require 'rdoc/markup'
-require 'tmpdir'
-require 'fileutils'
-
-class TestRDocRIStore < MiniTest::Unit::TestCase
-
-  def setup
-    RDoc::TopLevel.reset
-
-    @tmpdir = File.join Dir.tmpdir, "test_rdoc_ri_store_#{$$}"
-    @s = RDoc::RI::Store.new @tmpdir
-
-    @top_level = RDoc::TopLevel.new 'file.rb'
-
-    @klass = @top_level.add_class RDoc::NormalClass, 'Object'
-    @klass.comment = 'original'
-
-    @cmeth = RDoc::AnyMethod.new nil, 'cmethod'
-    @cmeth.singleton = true
-
-    @meth = RDoc::AnyMethod.new nil, 'method'
-    @meth_bang = RDoc::AnyMethod.new nil, 'method!'
-
-    @attr = RDoc::Attr.new nil, 'attr', 'RW', ''
-
-    @klass.add_method @cmeth
-    @klass.add_method @meth
-    @klass.add_method @meth_bang
-    @klass.add_attribute @attr
-
-    @nest_klass = @klass.add_class RDoc::NormalClass, 'SubClass'
-    @nest_meth = RDoc::AnyMethod.new nil, 'method'
-    @nest_incl = RDoc::Include.new 'Incl', ''
-
-    @nest_klass.add_method @nest_meth
-    @nest_klass.add_include @nest_incl
-
-    @RM = RDoc::Markup
-  end
-
-  def teardown
-    FileUtils.rm_rf @tmpdir
-  end
-
-  def assert_cache imethods, cmethods, attrs, modules, ancestors = {}
-    expected = {
-      :class_methods    => cmethods,
-      :instance_methods => imethods,
-      :attributes       => attrs,
-      :modules          => modules,
-      :ancestors        => ancestors
-    }
-
-    assert_equal expected, @s.cache
-  end
-
-  def assert_directory path
-    assert File.directory?(path), "#{path} is not a directory"
-  end
-
-  def assert_file path
-    assert File.file?(path), "#{path} is not a file"
-  end
-
-  def refute_file path
-    refute File.exist?(path), "#{path} exists"
-  end
-
-  def test_attributes
-    @s.cache[:attributes]['Object'] = %w[attr]
-
-    expected = { 'Object' => %w[attr] }
-
-    assert_equal expected, @s.attributes
-  end
-
-  def test_class_file
-    assert_equal File.join(@tmpdir, 'Object', 'cdesc-Object.ri'),
-                 @s.class_file('Object')
-    assert_equal File.join(@tmpdir, 'Object', 'SubClass', 'cdesc-SubClass.ri'),
-                 @s.class_file('Object::SubClass')
-  end
-
-  def test_class_methods
-    @s.cache[:class_methods]['Object'] = %w[method]
-
-    expected = { 'Object' => %w[method] }
-
-    assert_equal expected, @s.class_methods
-  end
-
-  def test_class_path
-    assert_equal File.join(@tmpdir, 'Object'), @s.class_path('Object')
-    assert_equal File.join(@tmpdir, 'Object', 'SubClass'),
-                 @s.class_path('Object::SubClass')
-  end
-
-  def test_dry_run
-    refute @s.dry_run
-
-    @s.dry_run = true
-
-    assert @s.dry_run
-  end
-
-  def test_friendly_path
-    @s.path = @tmpdir
-    @s.type = nil
-    assert_equal @s.path, @s.friendly_path
-
-    @s.type = :extra
-    assert_equal @s.path, @s.friendly_path
-
-    @s.type = :system
-    assert_equal "ruby core", @s.friendly_path
-
-    @s.type = :site
-    assert_equal "ruby site", @s.friendly_path
-
-    @s.type = :home
-    assert_equal "~/.ri", @s.friendly_path
-
-    @s.type = :gem
-    @s.path = "#{@tmpdir}/gem_repository/doc/gem_name-1.0/ri"
-    assert_equal "gem gem_name-1.0", @s.friendly_path
-  end
-
-  def test_instance_methods
-    @s.cache[:instance_methods]['Object'] = %w[method]
-
-    expected = { 'Object' => %w[method] }
-
-    assert_equal expected, @s.instance_methods
-  end
-
-  def test_load_cache
-    cache = {
-      :methods => %w[Object#method],
-      :modules => %w[Object],
-    }
-
-    Dir.mkdir @tmpdir
-
-    open File.join(@tmpdir, 'cache.ri'), 'wb' do |io|
-      Marshal.dump cache, io
-    end
-
-    @s.load_cache
-
-    assert_equal cache, @s.cache
-  end
-
-  def test_load_cache_no_cache
-    cache = {
-      :ancestors        => {},
-      :attributes       => {},
-      :class_methods    => {},
-      :instance_methods => {},
-      :modules          => [],
-    }
-
-    @s.load_cache
-
-    assert_equal cache, @s.cache
-  end
-
-  def test_load_class
-    @s.save_class @klass
-
-    assert_equal @klass, @s.load_class('Object')
-  end
-
-  def test_load_method_bang
-    @s.save_method @klass, @meth_bang
-
-    meth = @s.load_method('Object', '#method!')
-    assert_equal @meth_bang, meth
-  end
-
-  def test_method_file
-    assert_equal File.join(@tmpdir, 'Object', 'method-i.ri'),
-                 @s.method_file('Object', 'Object#method')
-
-    assert_equal File.join(@tmpdir, 'Object', 'method%21-i.ri'),
-                 @s.method_file('Object', 'Object#method!')
-
-    assert_equal File.join(@tmpdir, 'Object', 'SubClass', 'method%21-i.ri'),
-                 @s.method_file('Object::SubClass', 'Object::SubClass#method!')
-
-    assert_equal File.join(@tmpdir, 'Object', 'method-c.ri'),
-                 @s.method_file('Object', 'Object::method')
-  end
-
-  def test_save_cache
-    @s.save_class @klass
-    @s.save_method @klass, @meth
-    @s.save_method @klass, @cmeth
-    @s.save_class @nest_klass
-
-    @s.save_cache
-
-    assert_file File.join(@tmpdir, 'cache.ri')
-
-    expected = {
-      :attributes => { 'Object' => ['attr_accessor attr'] },
-      :class_methods => { 'Object' => %w[cmethod] },
-      :instance_methods => { 'Object' => %w[method] },
-      :modules => %w[Object Object::SubClass],
-      :ancestors => {
-        'Object'           => %w[],
-        'Object::SubClass' => %w[Incl Object],
-      },
-    }
-
-    open File.join(@tmpdir, 'cache.ri'), 'rb' do |io|
-      cache = Marshal.load io.read
-
-      assert_equal expected, cache
-    end
-  end
-
-  def test_save_cache_dry_run
-    @s.dry_run = true
-
-    @s.save_class @klass
-    @s.save_method @klass, @meth
-    @s.save_method @klass, @cmeth
-    @s.save_class @nest_klass
-
-    @s.save_cache
-
-    refute_file File.join(@tmpdir, 'cache.ri')
-  end
-
-  def test_save_cache_duplicate_methods
-    @s.save_method @klass, @meth
-    @s.save_method @klass, @meth
-
-    @s.save_cache
-
-    assert_cache({ 'Object' => %w[method] }, {}, {}, [])
-  end
-
-  def test_save_class
-    @s.save_class @klass
-
-    assert_directory File.join(@tmpdir, 'Object')
-    assert_file File.join(@tmpdir, 'Object', 'cdesc-Object.ri')
-
-    assert_cache({}, {}, { 'Object' => ['attr_accessor attr'] }, %w[Object],
-                 'Object' => %w[])
-
-    assert_equal @klass, @s.load_class('Object')
-  end
-
-  def test_save_class_basic_object
-    @klass.instance_variable_set :@superclass, nil
-
-    @s.save_class @klass
-
-    assert_directory File.join(@tmpdir, 'Object')
-    assert_file File.join(@tmpdir, 'Object', 'cdesc-Object.ri')
-
-    assert_cache({}, {}, { 'Object' => ['attr_accessor attr'] }, %w[Object],
-                 'Object' => %w[])
-
-    assert_equal @klass, @s.load_class('Object')
-  end
-
-  def test_save_class_dry_run
-    @s.dry_run = true
-
-    @s.save_class @klass
-
-    refute_file File.join(@tmpdir, 'Object')
-    refute_file File.join(@tmpdir, 'Object', 'cdesc-Object.ri')
-  end
-
-  def test_save_class_merge
-    @s.save_class @klass
-
-    klass = RDoc::NormalClass.new 'Object'
-    klass.comment = 'new class'
-
-    s = RDoc::RI::Store.new @tmpdir
-    s.save_class klass
-
-    s = RDoc::RI::Store.new @tmpdir
-
-    document = @RM::Document.new(
-      @RM::Paragraph.new('original'),
-      @RM::Paragraph.new('new class'))
-
-    assert_equal document, s.load_class('Object').comment
-  end
-
-  def test_save_class_methods
-    @s.save_class @klass
-
-    assert_directory File.join(@tmpdir, 'Object')
-    assert_file File.join(@tmpdir, 'Object', 'cdesc-Object.ri')
-
-    assert_cache({}, {}, { 'Object' => ['attr_accessor attr'] }, %w[Object],
-                 'Object' => %w[])
-
-    assert_equal @klass, @s.load_class('Object')
-  end
-
-  def test_save_class_nested
-    @s.save_class @nest_klass
-
-    assert_directory File.join(@tmpdir, 'Object', 'SubClass')
-    assert_file File.join(@tmpdir, 'Object', 'SubClass', 'cdesc-SubClass.ri')
-
-    assert_cache({}, {}, {}, %w[Object::SubClass],
-                 'Object::SubClass' => %w[Incl Object])
-  end
-
-  def test_save_method
-    @s.save_method @klass, @meth
-
-    assert_directory File.join(@tmpdir, 'Object')
-    assert_file File.join(@tmpdir, 'Object', 'method-i.ri')
-
-    assert_cache({ 'Object' => %w[method] }, {}, {}, [])
-
-    assert_equal @meth, @s.load_method('Object', '#method')
-  end
-
-  def test_save_method_dry_run
-    @s.dry_run = true
-
-    @s.save_method @klass, @meth
-
-    refute_file File.join(@tmpdir, 'Object')
-    refute_file File.join(@tmpdir, 'Object', 'method-i.ri')
-  end
-
-  def test_save_method_nested
-    @s.save_method @nest_klass, @nest_meth
-
-    assert_directory File.join(@tmpdir, 'Object', 'SubClass')
-    assert_file File.join(@tmpdir, 'Object', 'SubClass', 'method-i.ri')
-
-    assert_cache({ 'Object::SubClass' => %w[method] }, {}, {}, [])
-  end
-
-end
-

data/test/test_rdoc_ruby_lex.rb

@@ -1,23 +0,0 @@
-require 'rubygems'
-require 'minitest/autorun'
-require 'rdoc/rdoc'
-require 'rdoc/ruby_lex'
-
-class TestRubyLex < MiniTest::Unit::TestCase
-  def test_unary_minus
-    ruby_lex = RDoc::RubyLex.new("-1", nil)
-    assert_equal("-1", ruby_lex.token.value)
-
-    ruby_lex = RDoc::RubyLex.new("a[-2]", nil)
-    2.times { ruby_lex.token } # skip "a" and "["
-    assert_equal("-2", ruby_lex.token.value)
-
-    ruby_lex = RDoc::RubyLex.new("a[0..-12]", nil)
-    4.times { ruby_lex.token } # skip "a", "[", "0", and ".."
-    assert_equal("-12", ruby_lex.token.value)
-
-    ruby_lex = RDoc::RubyLex.new("0+-0.1", nil)
-    2.times { ruby_lex.token } # skip "0" and "+"
-    assert_equal("-0.1", ruby_lex.token.value)
-  end
-end

data/test/test_rdoc_stats.rb

@@ -1,38 +0,0 @@
-require 'rubygems'
-require 'minitest/autorun'
-require 'rdoc/stats'
-require 'rdoc/code_objects'
-require 'rdoc/markup'
-require 'rdoc/parser'
-
-class TestRDocStats < MiniTest::Unit::TestCase
-
-  def setup
-    RDoc::TopLevel.reset
-
-    @s = RDoc::Stats.new 0
-  end
-
-  def test_report_constant_alias
-    tl = RDoc::TopLevel.new 'fake.rb'
-    mod = tl.add_module RDoc::NormalModule, 'M'
-
-    c = tl.add_class RDoc::NormalClass, 'C'
-    mod.add_constant c
-
-    ca = RDoc::Constant.new 'CA', nil, nil
-    ca.is_alias_for = c
-
-    tl.add_constant ca
-
-    RDoc::TopLevel.complete :public
-
-    report = @s.report
-
-    # TODO change this to refute match, aliases should be ignored as they are
-    # programmer convenience constructs
-    assert_match(/class Object/, report)
-  end
-
-end
-

data/test/test_rdoc_task.rb

@@ -1,92 +0,0 @@
-require 'rubygems'
-require 'minitest/autorun'
-require 'rdoc/task'
-
-class TestRDocTask < MiniTest::Unit::TestCase
-
-  def setup
-    Rake::Task.clear
-  end
-
-  def test_inline_source
-    t = RDoc::Task.new
-
-    _, err = capture_io do
-      assert t.inline_source
-    end
-
-    assert_equal "RDoc::Task#inline_source is deprecated\n", err
-
-    _, err = capture_io do
-      t.inline_source = false
-    end
-
-    assert_equal "RDoc::Task#inline_source is deprecated\n", err
-
-    capture_io do
-      assert t.inline_source
-    end
-  end
-
-  def test_tasks_creation
-    RDoc::Task.new
-    assert Rake::Task[:rdoc]
-    assert Rake::Task[:clobber_rdoc]
-    assert Rake::Task[:rerdoc]
-  end
-
-  def test_tasks_creation_with_custom_name_symbol
-    rd = RDoc::Task.new(:rdoc_dev)
-    assert Rake::Task[:rdoc_dev]
-    assert Rake::Task[:clobber_rdoc_dev]
-    assert Rake::Task[:rerdoc_dev]
-    assert_equal :rdoc_dev, rd.name
-  end
-
-  def test_generator_option
-    rdoc_task = RDoc::Task.new do |rd|
-      rd.generator = "ri"
-    end
-
-    assert_equal %w[-o html -f ri], rdoc_task.option_list
-  end
-
-  def test_tasks_creation_with_custom_name_string
-    rd = RDoc::Task.new("rdoc_dev")
-    assert Rake::Task[:rdoc_dev]
-    assert Rake::Task[:clobber_rdoc_dev]
-    assert Rake::Task[:rerdoc_dev]
-    assert_equal "rdoc_dev", rd.name
-  end
-
-  def test_tasks_creation_with_custom_name_hash
-    options = { :rdoc => "rdoc", :clobber_rdoc => "rdoc:clean", :rerdoc => "rdoc:force" }
-    rd = RDoc::Task.new(options)
-    assert Rake::Task[:"rdoc"]
-    assert Rake::Task[:"rdoc:clean"]
-    assert Rake::Task[:"rdoc:force"]
-    assert_raises(RuntimeError) { Rake::Task[:clobber_rdoc] }
-    assert_equal options, rd.name
-  end
-
-  def test_tasks_creation_with_custom_name_hash_will_use_default_if_an_option_isnt_given
-    RDoc::Task.new(:clobber_rdoc => "rdoc:clean")
-    assert Rake::Task[:rdoc]
-    assert Rake::Task[:"rdoc:clean"]
-    assert Rake::Task[:rerdoc]
-  end
-
-  def test_tasks_creation_with_custom_name_hash_raises_exception_if_invalid_option_given
-    assert_raises(ArgumentError) do
-      RDoc::Task.new(:foo => "bar")
-    end
-
-    begin
-      RDoc::Task.new(:foo => "bar")
-    rescue ArgumentError => e
-      assert_match(/foo/, e.message)
-    end
-  end
-
-end
-