rdoc 4.2.1 → 6.3.1

data/test/test_rdoc_rd_inline.rb

@@ -1,63 +0,0 @@
-require 'rdoc/test_case'
-
-class TestRDocRdInline < RDoc::TestCase
-
-  def setup
-    super
-
-    @inline = RDoc::RD::Inline.new '+text+', 'text'
-  end
-
-  def test_class_new
-    inline = RDoc::RD::Inline.new @inline
-
-    refute_equal inline.rdoc, inline.reference
-  end
-
-  def test_initialize
-    inline = RDoc::RD::Inline.new 'text'
-
-    assert_equal inline.rdoc, inline.reference
-    refute_same  inline.rdoc, inline.reference
-  end
-
-  def test_initialize_inline
-    inline = RDoc::RD::Inline.new @inline
-
-    assert_equal '+text+', inline.rdoc
-    assert_equal 'text',   inline.reference
-  end
-
-  def test_append_inline
-    out = @inline.append @inline
-
-    assert_same @inline, out
-
-    assert_equal '+text++text+', @inline.rdoc
-    assert_equal 'texttext',     @inline.reference
-  end
-
-  def test_append_string
-    @inline.append ' more'
-
-    assert_equal '+text+ more', @inline.rdoc
-    assert_equal 'text more',   @inline.reference
-  end
-
-  def test_equals2
-    assert_equal @inline, RDoc::RD::Inline.new('+text+', 'text')
-    refute_equal @inline, RDoc::RD::Inline.new('+text+', 'other')
-    refute_equal @inline, RDoc::RD::Inline.new('+other+', 'text')
-    refute_equal @inline, Object.new
-  end
-
-  def test_inspect
-    assert_equal '(inline: +text+)', @inline.inspect
-  end
-
-  def test_to_s
-    assert_equal '+text+', @inline.to_s
-  end
-
-end
-

data/test/test_rdoc_rd_inline_parser.rb

@@ -1,177 +0,0 @@
-require 'rdoc/test_case'
-
-class TestRDocRdInlineParser < RDoc::TestCase
-
-  def setup
-    super
-
-    @block_parser = RDoc::RD::BlockParser.new
-    @block_parser.instance_variable_set :@i, 0
-    @inline_parser = RDoc::RD::InlineParser.new @block_parser
-  end
-
-  def test_parse
-    assert_equal 'regular <em>emphasis</em>', parse('regular ((*emphasis*))')
-  end
-
-  def test_parse_code
-    assert_equal '<code>text</code>', parse('(({text}))')
-  end
-
-  def test_parse_em
-    assert_equal '<em>text</em>', parse('((*text*))')
-  end
-
-  def test_parse_footnote
-    assert_equal '{*1}[rdoc-label:foottext-1:footmark-1]', parse('((-text-))')
-
-    expected = [
-      @RM::Paragraph.new('{^1}[rdoc-label:footmark-1:foottext-1]', ' ', 'text'),
-      blank_line,
-    ]
-
-    assert_equal expected, @block_parser.footnotes
-  end
-
-  def test_parse_index
-    assert_equal '<span id="label-text">text</span>', parse('((:text:))')
-
-    assert_includes @block_parser.labels, 'text'
-  end
-
-  def test_parse_kbd
-    assert_equal '<tt>text</tt>', parse('((%text%))')
-  end
-
-  def test_parse_multiple
-    assert_equal '<em>one</em> <em>two</em>', parse('((*one*)) ((*two*))')
-  end
-
-  def test_parse_newline
-    assert_equal "one\ntwo", parse("one\ntwo")
-  end
-
-  def test_parse_quote
-    assert_equal 'one " two', parse('one " two')
-  end
-
-  def test_parse_ref
-    assert_equal '{text}[rdoc-label:text]', parse('((<text>))')
-  end
-
-  def test_parse_ref_em
-    assert_equal '{<em>text</em>}[rdoc-label:text]', parse('((<((*text*))>))')
-  end
-
-  def test_parse_ref_filename_quote
-    assert_equal '{RD/foo}[rdoc-label:RD/foo]', parse('((<RD/"foo">))')
-  end
-
-  def test_parse_ref_filename
-    assert_equal '{RD}[rdoc-label:RD/]', parse('((<RD/>))')
-  end
-
-  def test_parse_ref_quote
-    assert_equal '{text \\"}[rdoc-label:text \\"]', parse('((<text \">))')
-  end
-
-  def test_parse_ref_quote_content
-    assert_equal '{<em>text</em>}[rdoc-label:text]',
-                 parse('((<"((*text*))">))')
-  end
-
-  def test_parse_ref_quote_content_multi
-    assert_equal '{<em>one</em> <em>two</em>}[rdoc-label:one two]',
-                 parse('((<"((*one*)) ((*two*))">))')
-  end
-
-  def test_parse_ref_substitute
-    assert_equal '{text}[rdoc-label:thing]', parse('((<text|thing>))')
-  end
-
-  def test_parse_ref_substitute_element_quote
-    assert_equal '{text}[rdoc-label:"RD"]',
-                 parse('((<text|"RD">))')
-  end
-
-  def test_parse_ref_substitute_filename
-    assert_equal '{text}[rdoc-label:RD/]', parse('((<text|RD/>))')
-  end
-
-  def test_parse_ref_substitute_filename_label
-    assert_equal '{text}[rdoc-label:RD/label]',
-                 parse('((<text|RD/label>))')
-  end
-
-  def test_parse_ref_substitute_filename_quote
-    assert_equal '{text}[rdoc-label:"RD"/]', parse('((<text|"RD"/>))')
-  end
-
-  def test_parse_ref_substitute_multi_content
-    assert_equal '{<em>one</em> two}[rdoc-label:thing]',
-                 parse('((<((*one*)) two|thing>))')
-  end
-
-  def test_parse_ref_substitute_multi_content2
-    assert_equal '{<em>one</em> \\" two}[rdoc-label:thing]',
-                 parse('((<((*one*)) \" two|thing>))')
-  end
-
-  def test_parse_ref_substitute_multi_content3
-    assert_equal '{<em>one</em> \\" <em>two</em>}[rdoc-label:thing]',
-                 parse('((<((*one*)) \" ((*two*))|thing>))')
-  end
-
-  def test_parse_ref_substitute_quote
-    assert_equal '{one | two}[rdoc-label:thing]',
-                 parse('((<"one | two"|thing>))')
-  end
-
-  def test_parse_ref_substitute_quote_content
-    assert_equal '{<em>text</em>}[rdoc-label:thing]',
-                 parse('((<"((*text*))"|thing>))')
-  end
-
-  def test_parse_ref_substitute_url
-    assert_equal '{text}[http://example]',
-                 parse('((<text|URL:http://example>))')
-  end
-
-  def test_parse_ref_url
-    assert_equal '{http://example}[http://example]',
-                 parse('((<URL:http://example>))')
-  end
-
-  def test_parse_var
-    assert_equal '+text+', parse('((|text|))')
-  end
-
-  def test_parse_verb
-    assert_equal '<tt>text</tt>', parse("(('text'))")
-  end
-
-  def test_parse_verb_backslash
-    assert_equal "<tt>(('text'))</tt>", parse("(('(('text\\'))'))")
-  end
-
-  def test_parse_verb_backslash_backslash
-    assert_equal '<tt>text \\</tt>', parse("(('text \\\\'))")
-  end
-
-  def test_parse_verb_backslash_quote
-    assert_equal '<tt>text "</tt>', parse("(('text \\\"'))")
-  end
-
-  def test_parse_verb_emphasis
-    assert_equal '<tt>((*emphasis*))</tt>', parse("(('((*emphasis*))'))")
-  end
-
-  def test_parse_verb_multiple
-    assert_equal '<tt>((*text*))</tt>', parse("(('((*text*))'))")
-  end
-
-  def parse text
-    @inline_parser.parse text
-  end
-
-end

data/test/test_rdoc_rdoc.rb

@@ -1,455 +0,0 @@
-require 'rdoc/test_case'
-
-class TestRDocRDoc < RDoc::TestCase
-
-  def setup
-    super
-
-    @rdoc = RDoc::RDoc.new
-    @rdoc.options = RDoc::Options.new
-
-    @stats = RDoc::Stats.new @store, 0, 0
-    @rdoc.instance_variable_set :@stats, @stats
-  end
-
-  def test_document # functional test
-    options = RDoc::Options.new
-    options.files = [File.expand_path('../xref_data.rb', __FILE__)]
-    options.setup_generator 'ri'
-    options.main_page = 'MAIN_PAGE.rdoc'
-    options.root      = Pathname File.expand_path('..', __FILE__)
-    options.title     = 'title'
-
-    rdoc = RDoc::RDoc.new
-
-    temp_dir do
-      options.op_dir = 'ri'
-
-      capture_io do
-        rdoc.document options
-      end
-
-      assert File.directory? 'ri'
-      assert_equal rdoc, rdoc.store.rdoc
-    end
-
-    store = rdoc.store
-
-    assert_equal 'MAIN_PAGE.rdoc', store.main
-    assert_equal 'title',          store.title
-  end
-
-  def test_gather_files
-    a = File.expand_path __FILE__
-    b = File.expand_path '../test_rdoc_text.rb', __FILE__
-
-    assert_equal [a, b], @rdoc.gather_files([b, a, b])
-  end
-
-  def test_handle_pipe
-    $stdin = StringIO.new "hello"
-
-    out, = capture_io do
-      @rdoc.handle_pipe
-    end
-
-    assert_equal "\n<p>hello</p>\n", out
-  ensure
-    $stdin = STDIN
-  end
-
-  def test_handle_pipe_rd
-    $stdin = StringIO.new "=begin\nhello\n=end"
-
-    @rdoc.options.markup = 'rd'
-
-    out, = capture_io do
-      @rdoc.handle_pipe
-    end
-
-    assert_equal "\n<p>hello</p>\n", out
-  ensure
-    $stdin = STDIN
-  end
-
-  def test_load_options
-    temp_dir do
-      options = RDoc::Options.new
-      options.markup = 'tomdoc'
-      options.write_options
-
-      options = @rdoc.load_options
-
-      assert_equal 'tomdoc', options.markup
-    end
-  end
-
-  def test_load_options_invalid
-    temp_dir do
-      open '.rdoc_options', 'w' do |io|
-        io.write "a: !ruby.yaml.org,2002:str |\nfoo"
-      end
-
-      e = assert_raises RDoc::Error do
-        @rdoc.load_options
-      end
-
-      options_file = File.expand_path '.rdoc_options'
-      assert_equal "#{options_file} is not a valid rdoc options file", e.message
-    end
-  end
-
-  def load_options_no_file
-    temp_dir do
-      options = @rdoc.load_options
-
-      assert_kind_of RDoc::Options, options
-    end
-  end
-
-  def test_normalized_file_list
-    files = temp_dir do |dir|
-      flag_file = @rdoc.output_flag_file dir
-
-      FileUtils.touch flag_file
-
-      @rdoc.normalized_file_list [__FILE__, flag_file]
-    end
-
-    files = files.map { |file| File.expand_path file }
-
-    assert_equal [File.expand_path(__FILE__)], files
-  end
-
-  def test_normalized_file_list_not_modified
-    files = [__FILE__]
-
-    @rdoc.last_modified[__FILE__] = File.stat(__FILE__).mtime
-
-    files = @rdoc.normalized_file_list [__FILE__]
-
-    assert_empty files
-  end
-
-  def test_normalized_file_list_non_file_directory
-    dev = defined?(File::NULL) ? File::NULL : '/dev/stdin'
-    skip "#{dev} is not a character special" unless
-      File.chardev? dev
-
-    files = nil
-
-    out, err = verbose_capture_io do
-      files = @rdoc.normalized_file_list [dev]
-    end
-
-    files = files.map { |file| File.expand_path file }
-
-    assert_empty files
-
-    assert_empty out
-    assert_match %r"^rdoc can't parse", err
-    assert_match %r"#{dev}$",           err
-  end
-
-  def test_parse_file
-    @rdoc.store = RDoc::Store.new
-
-    temp_dir do |dir|
-      @rdoc.options.root = Pathname(Dir.pwd)
-
-      open 'test.txt', 'w' do |io|
-        io.puts 'hi'
-      end
-
-      top_level = @rdoc.parse_file 'test.txt'
-
-      assert_equal 'test.txt', top_level.absolute_name
-      assert_equal 'test.txt', top_level.relative_name
-    end
-  end
-
-  def test_parse_file_binary
-    @rdoc.store = RDoc::Store.new
-
-    root = File.dirname __FILE__
-
-    @rdoc.options.root = Pathname root
-
-    out, err = capture_io do
-      Dir.chdir root do
-        assert_nil @rdoc.parse_file 'binary.dat'
-      end
-    end
-
-    assert_empty out
-    assert_empty err
-  end
-
-  def test_parse_file_include_root
-    @rdoc.store = RDoc::Store.new
-
-    top_level = nil
-    temp_dir do |dir|
-      @rdoc.options.parse %W[--root #{File.dirname(__FILE__)}]
-
-      open 'include.txt', 'w' do |io|
-        io.puts ':include: test.txt'
-      end
-
-      out, err = capture_io do
-        top_level = @rdoc.parse_file 'include.txt'
-      end
-      assert_empty out
-      assert_empty err
-    end
-    assert_equal "test file", top_level.comment.text
-  end
-
-  def test_parse_file_page_dir
-    @rdoc.store = RDoc::Store.new
-
-    temp_dir do |dir|
-      FileUtils.mkdir 'pages'
-      @rdoc.options.page_dir = Pathname('pages')
-      @rdoc.options.root = Pathname(Dir.pwd)
-
-      open 'pages/test.txt', 'w' do |io|
-        io.puts 'hi'
-      end
-
-      top_level = @rdoc.parse_file 'pages/test.txt'
-
-      assert_equal 'pages/test.txt', top_level.absolute_name
-      assert_equal 'test.txt',       top_level.relative_name
-    end
-  end
-
-  def test_parse_file_relative
-    pwd = Dir.pwd
-
-    @rdoc.store = RDoc::Store.new
-
-    temp_dir do |dir|
-      @rdoc.options.root = Pathname(dir)
-
-      open 'test.txt', 'w' do |io|
-        io.puts 'hi'
-      end
-
-      test_txt = File.join dir, 'test.txt'
-
-      Dir.chdir pwd do
-        top_level = @rdoc.parse_file test_txt
-
-        assert_equal test_txt,   top_level.absolute_name
-        assert_equal 'test.txt', top_level.relative_name
-      end
-    end
-  end
-
-  def test_parse_file_encoding
-    skip "Encoding not implemented" unless Object.const_defined? :Encoding
-    @rdoc.options.encoding = Encoding::ISO_8859_1
-    @rdoc.store = RDoc::Store.new
-
-    tf = Tempfile.open 'test.txt' do |io|
-      io.write 'hi'
-      io.rewind
-
-      top_level = @rdoc.parse_file io.path
-
-      assert_equal Encoding::ISO_8859_1, top_level.absolute_name.encoding
-      io
-    end
-    tf.close! if tf.respond_to? :close!
-  end
-
-  def test_parse_file_forbidden
-    skip 'chmod not supported' if Gem.win_platform?
-
-    @rdoc.store = RDoc::Store.new
-
-    tf = Tempfile.open 'test.txt' do |io|
-      io.write 'hi'
-      io.rewind
-
-      File.chmod 0000, io.path
-
-      begin
-        top_level = :bug
-
-        _, err = capture_io do
-          top_level = @rdoc.parse_file io.path
-        end
-
-        assert_match "Unable to read #{io.path},", err
-
-        assert_nil top_level
-      ensure
-        File.chmod 0400, io.path
-      end
-      io
-    end
-    tf.close! if tf.respond_to? :close!
-  end
-
-  def test_remove_unparseable
-    file_list = %w[
-      blah.class
-      blah.eps
-      blah.erb
-      blah.scpt.txt
-      blah.ttf
-      blah.yml
-    ]
-
-    assert_empty @rdoc.remove_unparseable file_list
-  end
-
-  def test_remove_unparseable_tags_emacs
-    temp_dir do
-      open 'TAGS', 'wb' do |io| # emacs
-        io.write "\f\nlib/foo.rb,43\n"
-      end
-
-      file_list = %w[
-        TAGS
-      ]
-
-      assert_empty @rdoc.remove_unparseable file_list
-    end
-  end
-
-  def test_remove_unparseable_tags_vim
-    temp_dir do
-      open 'TAGS', 'w' do |io| # emacs
-        io.write "!_TAG_"
-      end
-
-      file_list = %w[
-        TAGS
-      ]
-
-      assert_empty @rdoc.remove_unparseable file_list
-    end
-  end
-
-  def test_setup_output_dir
-    Dir.mktmpdir {|d|
-      path = File.join d, 'testdir'
-
-      last = @rdoc.setup_output_dir path, false
-
-      assert_empty last
-
-      assert File.directory? path
-      assert File.exist? @rdoc.output_flag_file path
-    }
-  end
-
-  def test_setup_output_dir_dry_run
-    @rdoc.options.dry_run = true
-
-    Dir.mktmpdir do |d|
-      path = File.join d, 'testdir'
-
-      @rdoc.setup_output_dir path, false
-
-      refute File.exist? path
-    end
-  end
-
-  def test_setup_output_dir_exists
-    Dir.mktmpdir {|path|
-      open @rdoc.output_flag_file(path), 'w' do |io|
-        io.puts Time.at 0
-        io.puts "./lib/rdoc.rb\t#{Time.at 86400}"
-      end
-
-      last = @rdoc.setup_output_dir path, false
-
-      assert_equal 1, last.size
-      assert_equal Time.at(86400), last['./lib/rdoc.rb']
-    }
-  end
-
-  def test_setup_output_dir_exists_empty_created_rid
-    Dir.mktmpdir {|path|
-      open @rdoc.output_flag_file(path), 'w' do end
-
-      e = assert_raises RDoc::Error do
-        @rdoc.setup_output_dir path, false
-      end
-
-      assert_match %r%Directory #{Regexp.escape path} already exists%, e.message
-    }
-  end
-
-  def test_setup_output_dir_exists_file
-    tf = Tempfile.open 'test_rdoc_rdoc' do |tempfile|
-      path = tempfile.path
-
-      e = assert_raises RDoc::Error do
-        @rdoc.setup_output_dir path, false
-      end
-
-      assert_match(%r%#{Regexp.escape path} exists and is not a directory%,
-                   e.message)
-      tempfile
-    end
-    tf.close! if tf.respond_to? :close!
-  end
-
-  def test_setup_output_dir_exists_not_rdoc
-    Dir.mktmpdir do |dir|
-      e = assert_raises RDoc::Error do
-        @rdoc.setup_output_dir dir, false
-      end
-
-      assert_match %r%Directory #{Regexp.escape dir} already exists%, e.message
-    end
-  end
-
-  def test_update_output_dir
-    Dir.mktmpdir do |d|
-      @rdoc.update_output_dir d, Time.now, {}
-
-      assert File.exist? "#{d}/created.rid"
-    end
-  end
-
-  def test_update_output_dir_dont
-    Dir.mktmpdir do |d|
-      @rdoc.options.update_output_dir = false
-      @rdoc.update_output_dir d, Time.now, {}
-
-      refute File.exist? "#{d}/created.rid"
-    end
-  end
-
-  def test_update_output_dir_dry_run
-    Dir.mktmpdir do |d|
-      @rdoc.options.dry_run = true
-      @rdoc.update_output_dir d, Time.now, {}
-
-      refute File.exist? "#{d}/created.rid"
-    end
-  end
-
-  def test_normalized_file_list_removes_created_rid_dir
-    temp_dir do |d|
-      FileUtils.mkdir "doc"
-      flag_file = @rdoc.output_flag_file "doc"
-      file = File.join "doc", "test"
-      FileUtils.touch flag_file
-      FileUtils.touch file
-
-      file_list = ["doc"]
-
-      output = @rdoc.normalized_file_list file_list
-
-      assert_empty output
-    end
-  end
-end
-

data/test/test_rdoc_require.rb

@@ -1,25 +0,0 @@
-require File.expand_path '../xref_test_case', __FILE__
-
-class TestRDocRequire < XrefTestCase
-
-  def setup
-    super
-
-    @req = RDoc::Require.new 'foo', 'comment'
-  end
-
-  def test_initialize
-    assert_equal 'foo', @req.name
-
-    req = RDoc::Require.new '"foo"', ''
-    assert_equal 'foo', @req.name
-
-    req = RDoc::Require.new '\'foo\'', ''
-    assert_equal 'foo', @req.name
-
-    req = RDoc::Require.new '|foo|', ''
-    assert_equal 'foo', @req.name, 'for fortran?'
-  end
-
-end
-