diff options
| author | Seb Bacon <seb.bacon@gmail.com> | 2012-03-12 13:05:19 +0000 |
|---|---|---|
| committer | Seb Bacon <seb.bacon@gmail.com> | 2012-03-12 13:05:19 +0000 |
| commit | 37bff4c0154b57b35a3194a9b31a9422496b955b (patch) | |
| tree | 61592a6bb9d1d9fea378a6e4efa8fdf7d5525b8a /vendor/gems/rdoc-2.4.3/test | |
| parent | 8b49dc894066e452232cabd09333895487f86986 (diff) | |
| parent | 8acea24f98268fbb9b73b66b9e98a1788a3b30ac (diff) | |
Merge branch 'merged-bundler' into develop
Diffstat (limited to 'vendor/gems/rdoc-2.4.3/test')
29 files changed, 0 insertions, 4385 deletions
diff --git a/vendor/gems/rdoc-2.4.3/test/binary.dat b/vendor/gems/rdoc-2.4.3/test/binary.dat Binary files differdeleted file mode 100644 index 371950efe..000000000 --- a/vendor/gems/rdoc-2.4.3/test/binary.dat +++ /dev/null diff --git a/vendor/gems/rdoc-2.4.3/test/test.ja.rdoc b/vendor/gems/rdoc-2.4.3/test/test.ja.rdoc deleted file mode 100644 index 96e1db93d..000000000 --- a/vendor/gems/rdoc-2.4.3/test/test.ja.rdoc +++ /dev/null @@ -1,8 +0,0 @@ -こんにちは！ - -初めまして。アーロンと申します。 - -どんな食べ物が好きですか？私はフランスの料理が大好きです。 -日本の料理も大好きです。 - -食べ物を食べるのが大好きだけど、お皿を洗うのが大嫌いです。 diff --git a/vendor/gems/rdoc-2.4.3/test/test.ja.txt b/vendor/gems/rdoc-2.4.3/test/test.ja.txt deleted file mode 100644 index 96e1db93d..000000000 --- a/vendor/gems/rdoc-2.4.3/test/test.ja.txt +++ /dev/null @@ -1,8 +0,0 @@ -こんにちは！ - -初めまして。アーロンと申します。 - -どんな食べ物が好きですか？私はフランスの料理が大好きです。 -日本の料理も大好きです。 - -食べ物を食べるのが大好きだけど、お皿を洗うのが大嫌いです。 diff --git a/vendor/gems/rdoc-2.4.3/test/test_attribute_manager.rb b/vendor/gems/rdoc-2.4.3/test/test_attribute_manager.rb deleted file mode 100644 index ee45c0596..000000000 --- a/vendor/gems/rdoc-2.4.3/test/test_attribute_manager.rb +++ /dev/null @@ -1,76 +0,0 @@ -require 'rubygems' -require 'minitest/unit' -require 'rdoc/markup/attribute_manager' - -class TestAttributeManager < MiniTest::Unit::TestCase - - def setup - @am = RDoc::Markup::AttributeManager.new - @klass = RDoc::Markup::AttributeManager - end - - def teardown - silently do - @klass.const_set(:MATCHING_WORD_PAIRS, {}) - @klass.const_set(:WORD_PAIR_MAP, {}) - @klass.const_set(:HTML_TAGS, {}) - end - end - - def test_initial_word_pairs - word_pairs = @klass::MATCHING_WORD_PAIRS - assert word_pairs.is_a?(Hash) - assert_equal(3, word_pairs.size) - end - - def test_initial_html - html_tags = @klass::HTML_TAGS - assert html_tags.is_a?(Hash) - assert_equal(5, html_tags.size) - end - - def test_add_matching_word_pair - @am.add_word_pair("x","x", :TEST) - word_pairs = @klass::MATCHING_WORD_PAIRS - assert_equal(4,word_pairs.size) - assert(word_pairs.has_key?("x")) - end - - def test_add_invalid_word_pair - assert_raises ArgumentError do - @am.add_word_pair("<", "<", :TEST) - end - end - - def test_add_word_pair_map - @am.add_word_pair("x", "y", :TEST) - word_pair_map = @klass::WORD_PAIR_MAP - assert_equal(1,word_pair_map.size) - assert_equal(word_pair_map. keys.first.source, "(x)(\\S+)(y)") - end - - def test_add_html_tag - @am.add_html("Test", :TEST) - tags = @klass::HTML_TAGS - assert_equal(6, tags.size) - assert(tags.has_key?("test")) - end - - def test_add_special - @am.add_special("WikiWord", :WIKIWORD) - specials = @klass::SPECIAL - assert_equal(1,specials.size) - assert(specials.has_key?("WikiWord")) - end - - def silently(&block) - warn_level = $VERBOSE - $VERBOSE = nil - result = block.call - $VERBOSE = warn_level - result - end - -end - -MiniTest::Unit.autorun diff --git a/vendor/gems/rdoc-2.4.3/test/test_rdoc_any_method.rb b/vendor/gems/rdoc-2.4.3/test/test_rdoc_any_method.rb deleted file mode 100644 index a4e30c42b..000000000 --- a/vendor/gems/rdoc-2.4.3/test/test_rdoc_any_method.rb +++ /dev/null @@ -1,10 +0,0 @@ -require 'test/xref_test_case' - -class RDocAnyMethodTest < XrefTestCase - - def test_full_name - assert_equal 'C1::m', @c1.method_list.first.full_name - end - -end - diff --git a/vendor/gems/rdoc-2.4.3/test/test_rdoc_code_object.rb b/vendor/gems/rdoc-2.4.3/test/test_rdoc_code_object.rb deleted file mode 100644 index 282ca1ecc..000000000 --- a/vendor/gems/rdoc-2.4.3/test/test_rdoc_code_object.rb +++ /dev/null @@ -1,80 +0,0 @@ -require 'rubygems' -require 'minitest/unit' -require 'test/xref_test_case' -require 'rdoc/code_object' - -class TestRDocCodeObject < XrefTestCase - - def setup - super - - @co = RDoc::CodeObject.new - end - - def test_initialize - assert @co.document_self, 'document_self' - assert @co.document_children, 'document_children' - refute @co.force_documentation, 'force_documentation' - refute @co.done_documenting, 'done_documenting' - assert_equal nil, @co.comment, 'comment is nil' - end - - def test_comment_equals - @co.comment = '' - - assert_equal nil, @co.comment - - @co.comment = 'I am a comment' - - assert_equal 'I am a comment', @co.comment - end - - def test_document_children_equals - @co.document_children = false - refute @co.document_children - - @c2.document_children = false - assert_empty @c2.classes - end - - def test_document_self_equals - @co.document_self = false - refute @co.document_self - - @c1.document_self = false - assert_empty @c1.method_list - end - - def test_parent_file_name - assert_equal '(unknown)', @co.parent_file_name - assert_equal 'xref_data.rb', @c1.parent_file_name - end - - def test_parent_name - assert_equal '(unknown)', @co.parent_name - assert_equal 'xref_data.rb', @c1.parent_name - assert_equal 'C2', @c2_c3.parent_name - end - - def test_start_doc - @co.document_self = false - @co.document_children = false - - @co.start_doc - - assert @co.document_self - assert @co.document_children - end - - def test_stop_doc - @co.document_self = true - @co.document_children = true - - @co.stop_doc - - refute @co.document_self - refute @co.document_children - end - -end - diff --git a/vendor/gems/rdoc-2.4.3/test/test_rdoc_constant.rb b/vendor/gems/rdoc-2.4.3/test/test_rdoc_constant.rb deleted file mode 100644 index 9ec697224..000000000 --- a/vendor/gems/rdoc-2.4.3/test/test_rdoc_constant.rb +++ /dev/null @@ -1,15 +0,0 @@ -require 'test/xref_test_case' - -class TestRDocConstant < XrefTestCase - - def setup - super - - @const = @c1.constants.first - end - - def test_path - assert_equal 'C1.html#CONST', @const.path - end - -end diff --git a/vendor/gems/rdoc-2.4.3/test/test_rdoc_context.rb b/vendor/gems/rdoc-2.4.3/test/test_rdoc_context.rb deleted file mode 100644 index 6360c5837..000000000 --- a/vendor/gems/rdoc-2.4.3/test/test_rdoc_context.rb +++ /dev/null @@ -1,250 +0,0 @@ -require 'rubygems' -require 'minitest/unit' -require 'test/xref_test_case' - -class TestRDocContext < XrefTestCase - - def setup - super - - @context = RDoc::Context.new - end - - def test_initialize - assert_empty @context.in_files - assert_equal 'unknown', @context.name - assert_equal '', @context.comment - assert_equal nil, @context.parent - assert_equal :public, @context.visibility - assert_equal 1, @context.sections.length - - assert_empty @context.classes_hash - assert_empty @context.modules_hash - - assert_empty @context.method_list - assert_empty @context.attributes - assert_empty @context.aliases - assert_empty @context.requires - assert_empty @context.includes - assert_empty @context.constants - end - - def test_add_alias - as = RDoc::Alias.new nil, 'old_name', 'new_name', 'comment' - - @context.add_alias as - - assert_equal [as], @context.aliases - assert_equal [as], @context.unmatched_alias_lists['old_name'] - end - - def test_add_alias_method - meth = RDoc::AnyMethod.new nil, 'old_name' - as = RDoc::Alias.new nil, 'old_name', 'new_name', 'comment' - as.parent = @context - - @context.add_method meth - @context.add_alias as - - assert_empty @context.aliases - assert_empty @context.unmatched_alias_lists - assert_equal %w[old_name new_name], @context.method_list.map { |m| m.name } - end - - def test_add_class - @c1.add_class RDoc::NormalClass, 'Klass', 'Object' - - assert_includes @c1.classes.map { |k| k.full_name }, 'C1::Klass' - assert_includes RDoc::TopLevel.classes.map { |k| k.full_name }, 'C1::Klass' - end - - def test_add_class_upgrade - @c1.add_module RDoc::NormalModule, 'Klass' - @c1.add_class RDoc::NormalClass, 'Klass', nil - - assert_includes @c1.classes.map { |k| k.full_name }, 'C1::Klass', - 'c1 classes' - refute_includes @c1.modules.map { |k| k.full_name }, 'C1::Klass', - 'c1 modules' - - assert_includes RDoc::TopLevel.classes.map { |k| k.full_name }, 'C1::Klass', - 'TopLevel classes' - refute_includes RDoc::TopLevel.modules.map { |k| k.full_name }, 'C1::Klass', - 'TopLevel modules' - end - - def test_add_constant - const = RDoc::Constant.new 'NAME', 'value', 'comment' - @context.add_constant const - - assert_equal [const], @context.constants - end - - def test_add_include - incl = RDoc::Include.new 'Name', 'comment' - @context.add_include incl - - assert_equal [incl], @context.includes - end - - def test_add_method - meth = RDoc::AnyMethod.new nil, 'old_name' - meth.visibility = nil - - @context.add_method meth - - assert_equal [meth], @context.method_list - assert_equal :public, meth.visibility - end - - def test_add_method_alias - as = RDoc::Alias.new nil, 'old_name', 'new_name', 'comment' - meth = RDoc::AnyMethod.new nil, 'old_name' - - @context.add_alias as - refute_empty @context.aliases - - @context.add_method meth - - assert_empty @context.aliases - assert_empty @context.unmatched_alias_lists - assert_equal %w[old_name new_name], @context.method_list.map { |m| m.name } - end - - def test_add_module - @c1.add_module RDoc::NormalModule, 'Mod' - - assert_includes @c1.modules.map { |m| m.full_name }, 'C1::Mod' - end - - def test_add_module_class - k = @c1.add_class RDoc::NormalClass, 'Klass', nil - m = @c1.add_module RDoc::NormalModule, 'Klass' - - assert_equal k, m, 'returns class' - assert_empty @c1.modules - end - - def test_add_require - req = RDoc::Require.new 'require', 'comment' - @c1.add_require req - - assert_empty @c1.requires - assert_includes @c1.top_level.requires, req - end - - def test_add_to - incl = RDoc::Include.new 'Name', 'comment' - arr = [] - @context.add_to arr, incl - - assert_includes arr, incl - assert_equal @context, incl.parent - assert_equal @context.current_section, incl.section - end - - def test_add_to_no_document_self - incl = RDoc::Include.new 'Name', 'comment' - arr = [] - @context.document_self = false - @context.add_to arr, incl - - refute_includes arr, incl - end - - def test_add_to_done_documenting - incl = RDoc::Include.new 'Name', 'comment' - arr = [] - @context.done_documenting = true - @context.add_to arr, incl - - refute_includes arr, incl - end - - def test_classes - assert_equal %w[C2::C3], @c2.classes.map { |k| k.full_name } - assert_equal %w[C3::H1 C3::H2], @c3.classes.map { |k| k.full_name } - end - - def test_defined_in_eh - assert @c1.defined_in?(@c1.top_level) - - refute @c1.defined_in?(RDoc::TopLevel.new('name.rb')) - end - - def test_equals2 - assert_equal @c3, @c3 - refute_equal @c2, @c3 - refute_equal @c2_c3, @c3 - end - - def test_find_attribute_named - assert_equal nil, @c1.find_attribute_named('none') - assert_equal 'R', @c1.find_attribute_named('attr').rw - assert_equal 'R', @c1.find_attribute_named('attr_reader').rw - assert_equal 'W', @c1.find_attribute_named('attr_writer').rw - assert_equal 'RW', @c1.find_attribute_named('attr_accessor').rw - end - - def test_find_constant_named - assert_equal nil, @c1.find_constant_named('NONE') - assert_equal ':const', @c1.find_constant_named('CONST').value - end - - def test_find_enclosing_module_named - assert_equal nil, @c2_c3.find_enclosing_module_named('NONE') - assert_equal @c1, @c2_c3.find_enclosing_module_named('C1') - assert_equal @c2, @c2_c3.find_enclosing_module_named('C2') - end - - def test_find_file_named - assert_equal nil, @c1.find_file_named('nonexistent.rb') - assert_equal @xref_data, @c1.find_file_named(@file_name) - end - - def test_find_instance_method_named - assert_equal nil, @c1.find_instance_method_named('none') - - m = @c1.find_instance_method_named('m') - assert_instance_of RDoc::AnyMethod, m - assert_equal false, m.singleton - end - - def test_find_local_symbol - assert_equal true, @c1.find_local_symbol('m').singleton - assert_equal ':const', @c1.find_local_symbol('CONST').value - assert_equal 'R', @c1.find_local_symbol('attr').rw - assert_equal @xref_data, @c1.find_local_symbol(@file_name) - assert_equal @c2_c3, @c2.find_local_symbol('C3') - end - - def test_find_method_named - assert_equal true, @c1.find_method_named('m').singleton - end - - def test_find_module_named - assert_equal @c2_c3, @c2.find_module_named('C3') - assert_equal @c2, @c2.find_module_named('C2') - assert_equal @c1, @c2.find_module_named('C1') - - assert_equal 'C2::C3', @c2.find_module_named('C3').full_name - end - - def test_find_symbol - c3 = @xref_data.find_module_named('C3') - assert_equal c3, @xref_data.find_symbol('C3') - assert_equal c3, @c2.find_symbol('::C3') - assert_equal @c2_c3, @c2.find_symbol('C3') - end - - def test_spaceship - assert_equal(-1, @c2.<=>(@c3)) - assert_equal 0, @c2.<=>(@c2) - assert_equal 1, @c3.<=>(@c2) - - assert_equal 1, @c2_c3.<=>(@c2) - assert_equal(-1, @c2_c3.<=>(@c3)) - end - -end - diff --git a/vendor/gems/rdoc-2.4.3/test/test_rdoc_include.rb b/vendor/gems/rdoc-2.4.3/test/test_rdoc_include.rb deleted file mode 100644 index 6e305dd13..000000000 --- a/vendor/gems/rdoc-2.4.3/test/test_rdoc_include.rb +++ /dev/null @@ -1,17 +0,0 @@ -require 'test/xref_test_case' - -class TestRDocInclude < XrefTestCase - - def setup - super - - @inc = RDoc::Include.new 'M1', 'comment' - end - - def test_module - assert_equal @m1, @inc.module - assert_equal 'Unknown', RDoc::Include.new('Unknown', 'comment').module - end - -end - diff --git a/vendor/gems/rdoc-2.4.3/test/test_rdoc_markup.rb b/vendor/gems/rdoc-2.4.3/test/test_rdoc_markup.rb deleted file mode 100644 index ce962a2c5..000000000 --- a/vendor/gems/rdoc-2.4.3/test/test_rdoc_markup.rb +++ /dev/null @@ -1,626 +0,0 @@ -require 'rubygems' -require 'minitest/unit' -require 'rdoc/markup' -require 'rdoc/markup/to_test' - -class TestRDocMarkup < MiniTest::Unit::TestCase - - def basic_conv(str) - sm = RDoc::Markup.new - mock = RDoc::Markup::ToTest.new - sm.convert(str, mock) - sm.content - end - - def line_groups(str, expected) - m = RDoc::Markup.new - mock = RDoc::Markup::ToTest.new - - block = m.convert(str, mock) - - unless block == expected then - rows = (0...([expected.size, block.size].max)).collect{|i| - [expected[i]||"nil", block[i]||"nil"] - } - printf "\n\n%35s %35s\n", "Expected", "Got" - rows.each { |e,g| printf "%35s %35s\n", e.dump, g.dump } - end - - assert_equal(expected, block) - end - - def line_types(str, expected) - m = RDoc::Markup.new - mock = RDoc::Markup::ToTest.new - m.convert(str, mock) - assert_equal(expected, m.get_line_types.map{|type| type.to_s[0,1]}.join('')) - end - - def test_groups - str = "now is the time" - line_groups(str, ["L0: Paragraph\nnow is the time"] ) - - str = "now is the time\nfor all good men" - line_groups(str, ["L0: Paragraph\nnow is the time for all good men"] ) - - str = %{\ - now is the time - code _line_ here - for all good men} - - line_groups(str, - [ "L0: Paragraph\nnow is the time", - "L0: Verbatim\n code _line_ here\n", - "L0: Paragraph\nfor all good men" - ] ) - - str = "now is the time\n code\n more code\nfor all good men" - line_groups(str, - [ "L0: Paragraph\nnow is the time", - "L0: Verbatim\n code\n more code\n", - "L0: Paragraph\nfor all good men" - ] ) - - str = %{\ - now is - * l1 - * l2 - the time} - line_groups(str, - [ "L0: Paragraph\nnow is", - "L1: ListStart\n", - "L1: BULLET ListItem\nl1", - "L1: BULLET ListItem\nl2", - "L1: ListEnd\n", - "L0: Paragraph\nthe time" - ]) - - str = %{\ - now is - * l1 - l1+ - * l2 - the time} - line_groups(str, - [ "L0: Paragraph\nnow is", - "L1: ListStart\n", - "L1: BULLET ListItem\nl1 l1+", - "L1: BULLET ListItem\nl2", - "L1: ListEnd\n", - "L0: Paragraph\nthe time" - ]) - - str = %{\ - now is - * l1 - * l1.1 - * l2 - the time} - line_groups(str, - [ "L0: Paragraph\nnow is", - "L1: ListStart\n", - "L1: BULLET ListItem\nl1", - "L2: ListStart\n", - "L2: BULLET ListItem\nl1.1", - "L2: ListEnd\n", - "L1: BULLET ListItem\nl2", - "L1: ListEnd\n", - "L0: Paragraph\nthe time" - ]) - - - str = %{\ - now is - * l1 - * l1.1 - text - code - code - - text - * l2 - the time} - line_groups(str, - [ "L0: Paragraph\nnow is", - "L1: ListStart\n", - "L1: BULLET ListItem\nl1", - "L2: ListStart\n", - "L2: BULLET ListItem\nl1.1 text", - "L2: Verbatim\n code\n code\n", - "L2: Paragraph\ntext", - "L2: ListEnd\n", - "L1: BULLET ListItem\nl2", - "L1: ListEnd\n", - "L0: Paragraph\nthe time" - ]) - - - str = %{\ - now is - 1. l1 - * l1.1 - 2. l2 - the time} - line_groups(str, - [ "L0: Paragraph\nnow is", - "L1: ListStart\n", - "L1: NUMBER ListItem\nl1", - "L2: ListStart\n", - "L2: BULLET ListItem\nl1.1", - "L2: ListEnd\n", - "L1: NUMBER ListItem\nl2", - "L1: ListEnd\n", - "L0: Paragraph\nthe time" - ]) - - str = %{\ - now is - [cat] l1 - * l1.1 - [dog] l2 - the time} - line_groups(str, - [ "L0: Paragraph\nnow is", - "L1: ListStart\n", - "L1: LABELED ListItem\ncat: l1", - "L2: ListStart\n", - "L2: BULLET ListItem\nl1.1", - "L2: ListEnd\n", - "L1: LABELED ListItem\ndog: l2", - "L1: ListEnd\n", - "L0: Paragraph\nthe time" - ]) - - str = %{\ - now is - [cat] l1 - continuation - [dog] l2 - the time} - line_groups(str, - [ "L0: Paragraph\nnow is", - "L1: ListStart\n", - "L1: LABELED ListItem\ncat: l1 continuation", - "L1: LABELED ListItem\ndog: l2", - "L1: ListEnd\n", - "L0: Paragraph\nthe time" - ]) - end - - def test_headings - str = "= heading one" - line_groups(str, - [ "L0: Heading\nheading one" - ]) - - str = "=== heading three" - line_groups(str, - [ "L0: Heading\nheading three" - ]) - - str = "text\n === heading three" - line_groups(str, - [ "L0: Paragraph\ntext", - "L0: Verbatim\n === heading three\n" - ]) - - str = "text\n code\n === heading three" - line_groups(str, - [ "L0: Paragraph\ntext", - "L0: Verbatim\n code\n === heading three\n" - ]) - - str = "text\n code\n=== heading three" - line_groups(str, - [ "L0: Paragraph\ntext", - "L0: Verbatim\n code\n", - "L0: Heading\nheading three" - ]) - - end - - def test_list_alpha - str = "a. alpha\nb. baker\nB. ALPHA\nA. BAKER" - - line_groups(str, - [ "L1: ListStart\n", - "L1: LOWERALPHA ListItem\nalpha", - "L1: LOWERALPHA ListItem\nbaker", - "L1: ListEnd\n", - "L1: ListStart\n", - "L1: UPPERALPHA ListItem\nALPHA", - "L1: UPPERALPHA ListItem\nBAKER", - "L1: ListEnd\n" ]) - end - - def test_list_bullet_dash - str = "- one\n- two\n" - - line_groups(str, - [ "L1: ListStart\n", - "L1: BULLET ListItem\none", - "L1: BULLET ListItem\ntwo", - "L1: ListEnd\n" ]) - end - - def test_list_bullet_star - str = "* one\n* two\n" - - line_groups(str, - [ "L1: ListStart\n", - "L1: BULLET ListItem\none", - "L1: BULLET ListItem\ntwo", - "L1: ListEnd\n" ]) - end - - def test_list_labeled_bracket - str = "[one] item one\n[two] item two" - - line_groups(str, - [ "L1: ListStart\n", - "L1: LABELED ListItem\none: item one", - "L1: LABELED ListItem\ntwo: item two", - "L1: ListEnd\n" ]) - end - - def test_list_labeled_bracket_continued - str = "[one]\n item one\n[two]\n item two" - - line_groups(str, - [ "L1: ListStart\n", - "L1: LABELED ListItem\none: item one", - "L1: LABELED ListItem\ntwo: item two", - "L1: ListEnd\n" ]) - end - - def test_list_labeled_colon - str = "one:: item one\ntwo:: item two" - - line_groups(str, - [ "L1: ListStart\n", - "L1: NOTE ListItem\none:: item one", - "L1: NOTE ListItem\ntwo:: item two", - "L1: ListEnd\n" ]) - end - - def test_list_labeled_colon_continued - str = "one::\n item one\ntwo::\n item two" - - line_groups(str, - [ "L1: ListStart\n", - "L1: NOTE ListItem\none:: item one", - "L1: NOTE ListItem\ntwo:: item two", - "L1: ListEnd\n" ]) - end - - def test_list_nested_bullet_bullet - str = "* one\n* two\n * cat\n * dog" - - line_groups(str, - [ "L1: ListStart\n", - "L1: BULLET ListItem\none", - "L1: BULLET ListItem\ntwo", - "L2: ListStart\n", - "L2: BULLET ListItem\ncat", - "L2: BULLET ListItem\ndog", - "L2: ListEnd\n", - "L1: ListEnd\n" ]) - end - - def test_list_nested_labeled_bullet - str = "[one]\n * cat\n * dog" - - line_groups(str, - [ "L1: ListStart\n", - "L1: LABELED ListItem\none: ", - "L2: ListStart\n", - "L2: BULLET ListItem\ncat", - "L2: BULLET ListItem\ndog", - "L2: ListEnd\n", - "L1: ListEnd\n" ]) - end - - def test_list_nested_labeled_bullet_bullet - str = "[one]\n * cat\n * dog" - - line_groups(str, - [ "L1: ListStart\n", - "L1: LABELED ListItem\none: ", - "L2: ListStart\n", - "L2: BULLET ListItem\ncat", - "L3: ListStart\n", - "L3: BULLET ListItem\ndog", - "L3: ListEnd\n", - "L2: ListEnd\n", - "L1: ListEnd\n" ]) - end - - def test_list_nested_number_number - str = "1. one\n1. two\n 1. cat\n 1. dog" - - line_groups(str, - [ "L1: ListStart\n", - "L1: NUMBER ListItem\none", - "L1: NUMBER ListItem\ntwo", - "L2: ListStart\n", - "L2: NUMBER ListItem\ncat", - "L2: NUMBER ListItem\ndog", - "L2: ListEnd\n", - "L1: ListEnd\n" ]) - end - - def test_list_number - str = "1. one\n2. two\n1. three" - - line_groups(str, - [ "L1: ListStart\n", - "L1: NUMBER ListItem\none", - "L1: NUMBER ListItem\ntwo", - "L1: NUMBER ListItem\nthree", - "L1: ListEnd\n" ]) - end - - def test_list_split - str = %{\ - now is - * l1 - 1. n1 - 2. n2 - * l2 - the time} - line_groups(str, - [ "L0: Paragraph\nnow is", - "L1: ListStart\n", - "L1: BULLET ListItem\nl1", - "L1: ListEnd\n", - "L1: ListStart\n", - "L1: NUMBER ListItem\nn1", - "L1: NUMBER ListItem\nn2", - "L1: ListEnd\n", - "L1: ListStart\n", - "L1: BULLET ListItem\nl2", - "L1: ListEnd\n", - "L0: Paragraph\nthe time" - ]) - - end - - def test_list_verbatim - str = "* one\n verb1\n verb2\n* two\n" - - line_groups(str, - [ "L1: ListStart\n", - "L1: BULLET ListItem\none", - "L1: Verbatim\n verb1\n verb2\n", - "L1: BULLET ListItem\ntwo", - "L1: ListEnd\n" ]) - end - - def test_paragraph - str = "paragraph\n\n*bold* paragraph\n" - - line_groups str, [ - "L0: Paragraph\nparagraph", - "L0: BlankLine\n", - "L0: Paragraph\n*bold* paragraph" - ] - end - - def test_tabs - str = "hello\n dave" - assert_equal(str, basic_conv(str)) - str = "hello\n\tdave" - assert_equal("hello\n dave", basic_conv(str)) - str = "hello\n \tdave" - assert_equal("hello\n dave", basic_conv(str)) - str = "hello\n \tdave" - assert_equal("hello\n dave", basic_conv(str)) - str = "hello\n \tdave" - assert_equal("hello\n dave", basic_conv(str)) - str = "hello\n \tdave" - assert_equal("hello\n dave", basic_conv(str)) - str = "hello\n \tdave" - assert_equal("hello\n dave", basic_conv(str)) - str = "hello\n \tdave" - assert_equal("hello\n dave", basic_conv(str)) - str = "hello\n \tdave" - assert_equal("hello\n dave", basic_conv(str)) - str = "hello\n \tdave" - assert_equal("hello\n dave", basic_conv(str)) - str = ".\t\t." - assert_equal(". .", basic_conv(str)) - end - - def test_types - str = "now is the time" - line_types(str, 'P') - - str = "now is the time\nfor all good men" - line_types(str, 'PP') - - str = "now is the time\n code\nfor all good men" - line_types(str, 'PVP') - - str = "now is the time\n code\n more code\nfor all good men" - line_types(str, 'PVVP') - - str = "now is\n---\nthe time" - line_types(str, 'PRP') - - str = %{\ - now is - * l1 - * l2 - the time} - line_types(str, 'PLLP') - - str = %{\ - now is - * l1 - l1+ - * l2 - the time} - line_types(str, 'PLPLP') - - str = %{\ - now is - * l1 - * l1.1 - * l2 - the time} - line_types(str, 'PLLLP') - - str = %{\ - now is - * l1 - * l1.1 - text - code - code - - text - * l2 - the time} - line_types(str, 'PLLPVVBPLP') - - str = %{\ - now is - 1. l1 - * l1.1 - 2. l2 - the time} - line_types(str, 'PLLLP') - - str = %{\ - now is - [cat] l1 - * l1.1 - [dog] l2 - the time} - line_types(str, 'PLLLP') - - str = %{\ - now is - [cat] l1 - continuation - [dog] l2 - the time} - line_types(str, 'PLPLP') - end - - def test_verbatim - str = "paragraph\n *bold* verbatim\n" - - line_groups str, [ - "L0: Paragraph\nparagraph", - "L0: Verbatim\n *bold* verbatim\n" - ] - end - - def test_verbatim_merge - str = %{\ - now is - code - the time} - - line_groups(str, - [ "L0: Paragraph\nnow is", - "L0: Verbatim\n code\n", - "L0: Paragraph\nthe time" - ]) - - - str = %{\ - now is - code - code1 - the time} - - line_groups(str, - [ "L0: Paragraph\nnow is", - "L0: Verbatim\n code\n code1\n", - "L0: Paragraph\nthe time" - ]) - - - str = %{\ - now is - code - - code1 - the time} - - line_groups(str, - [ "L0: Paragraph\nnow is", - "L0: Verbatim\n code\n\n code1\n", - "L0: Paragraph\nthe time" - ]) - - - str = %{\ - now is - code - - code1 - - the time} - - line_groups(str, - [ "L0: Paragraph\nnow is", - "L0: Verbatim\n code\n\n code1\n", - "L0: Paragraph\nthe time" - ]) - - - str = %{\ - now is - code - - code1 - - code2 - the time} - - line_groups(str, - [ "L0: Paragraph\nnow is", - "L0: Verbatim\n code\n\n code1\n\n code2\n", - "L0: Paragraph\nthe time" - ]) - - - # Folds multiple blank lines - str = %{\ - now is - code - - - code1 - - the time} - - line_groups(str, - [ "L0: Paragraph\nnow is", - "L0: Verbatim\n code\n\n code1\n", - "L0: Paragraph\nthe time" - ]) - - - end - - def test_whitespace - assert_equal("hello", basic_conv("hello")) - assert_equal("hello", basic_conv(" hello ")) - assert_equal("hello", basic_conv(" \t \t hello\t\t")) - - assert_equal("1\n 2\n 3", basic_conv("1\n 2\n 3")) - assert_equal("1\n 2\n 3", basic_conv(" 1\n 2\n 3")) - - assert_equal("1\n 2\n 3\n1\n 2", basic_conv("1\n 2\n 3\n1\n 2")) - assert_equal("1\n 2\n 3\n1\n 2", basic_conv(" 1\n 2\n 3\n 1\n 2")) - - assert_equal("1\n 2\n\n 3", basic_conv(" 1\n 2\n\n 3")) - end - -end - -MiniTest::Unit.autorun diff --git a/vendor/gems/rdoc-2.4.3/test/test_rdoc_markup_attribute_manager.rb b/vendor/gems/rdoc-2.4.3/test/test_rdoc_markup_attribute_manager.rb deleted file mode 100644 index 0864523a0..000000000 --- a/vendor/gems/rdoc-2.4.3/test/test_rdoc_markup_attribute_manager.rb +++ /dev/null @@ -1,243 +0,0 @@ -require "rubygems" -require "minitest/unit" -require "rdoc/markup/inline" -require "rdoc/markup/to_html_crossref" - -class TestRDocMarkupAttributeManager < MiniTest::Unit::TestCase - - def setup - @orig_special = RDoc::Markup::AttributeManager::SPECIAL - RDoc::Markup::AttributeManager::SPECIAL.replace Hash.new - - @am = RDoc::Markup::AttributeManager.new - - @bold_on = @am.changed_attribute_by_name([], [:BOLD]) - @bold_off = @am.changed_attribute_by_name([:BOLD], []) - - @tt_on = @am.changed_attribute_by_name([], [:TT]) - @tt_off = @am.changed_attribute_by_name([:TT], []) - - @em_on = @am.changed_attribute_by_name([], [:EM]) - @em_off = @am.changed_attribute_by_name([:EM], []) - - @bold_em_on = @am.changed_attribute_by_name([], [:BOLD] | [:EM]) - @bold_em_off = @am.changed_attribute_by_name([:BOLD] | [:EM], []) - - @em_then_bold = @am.changed_attribute_by_name([:EM], [:EM] | [:BOLD]) - - @em_to_bold = @am.changed_attribute_by_name([:EM], [:BOLD]) - - @am.add_word_pair("{", "}", :WOMBAT) - @wombat_on = @am.changed_attribute_by_name([], [:WOMBAT]) - @wombat_off = @am.changed_attribute_by_name([:WOMBAT], []) - end - - def teardown - RDoc::Markup::AttributeManager::SPECIAL.replace @orig_special - end - - def crossref(text) - crossref_bitmap = RDoc::Markup::Attribute.bitmap_for(:_SPECIAL_) | - RDoc::Markup::Attribute.bitmap_for(:CROSSREF) - - [ @am.changed_attribute_by_name([], [:CROSSREF, :_SPECIAL_]), - RDoc::Markup::Special.new(crossref_bitmap, text), - @am.changed_attribute_by_name([:CROSSREF, :_SPECIAL_], []) - ] - end - - def test_adding - assert_equal(["cat ", @wombat_on, "and", @wombat_off, " dog" ], - @am.flow("cat {and} dog")) - #assert_equal(["cat {and} dog" ], @am.flow("cat \\{and} dog")) - end - - def test_add_word_pair - @am.add_word_pair '%', '&', 'percent and' - - assert RDoc::Markup::AttributeManager::WORD_PAIR_MAP.include?(/(%)(\S+)(&)/) - assert RDoc::Markup::AttributeManager::PROTECTABLE.include?('%') - assert !RDoc::Markup::AttributeManager::PROTECTABLE.include?('&') - end - - def test_add_word_pair_angle - e = assert_raises ArgumentError do - @am.add_word_pair '<', '>', 'angles' - end - - assert_equal "Word flags may not start with '<'", e.message - end - - def test_add_word_pair_matching - @am.add_word_pair '^', '^', 'caret' - - assert RDoc::Markup::AttributeManager::MATCHING_WORD_PAIRS.include?('^') - assert RDoc::Markup::AttributeManager::PROTECTABLE.include?('^') - end - - def test_basic - assert_equal(["cat"], @am.flow("cat")) - - assert_equal(["cat ", @bold_on, "and", @bold_off, " dog"], - @am.flow("cat *and* dog")) - - assert_equal(["cat ", @bold_on, "AND", @bold_off, " dog"], - @am.flow("cat *AND* dog")) - - assert_equal(["cat ", @em_on, "And", @em_off, " dog"], - @am.flow("cat _And_ dog")) - - assert_equal(["cat *and dog*"], @am.flow("cat *and dog*")) - - assert_equal(["*cat and* dog"], @am.flow("*cat and* dog")) - - assert_equal(["cat *and ", @bold_on, "dog", @bold_off], - @am.flow("cat *and *dog*")) - - assert_equal(["cat ", @em_on, "and", @em_off, " dog"], - @am.flow("cat _and_ dog")) - - assert_equal(["cat_and_dog"], - @am.flow("cat_and_dog")) - - assert_equal(["cat ", @tt_on, "and", @tt_off, " dog"], - @am.flow("cat +and+ dog")) - - assert_equal(["cat ", @bold_on, "a_b_c", @bold_off, " dog"], - @am.flow("cat *a_b_c* dog")) - - assert_equal(["cat __ dog"], - @am.flow("cat __ dog")) - - assert_equal(["cat ", @em_on, "_", @em_off, " dog"], - @am.flow("cat ___ dog")) - end - - def test_bold - assert_equal [@bold_on, 'bold', @bold_off], - @am.flow("*bold*") - - assert_equal [@bold_on, 'Bold:', @bold_off], - @am.flow("*Bold:*") - - assert_equal [@bold_on, '\\bold', @bold_off], - @am.flow("*\\bold*") - end - - def test_bold_html_escaped - assert_equal ['cat <b>dog</b>'], @am.flow('cat \<b>dog</b>') - end - - def test_combined - assert_equal(["cat ", @em_on, "and", @em_off, " ", @bold_on, "dog", @bold_off], - @am.flow("cat _and_ *dog*")) - - assert_equal(["cat ", @em_on, "a__nd", @em_off, " ", @bold_on, "dog", @bold_off], - @am.flow("cat _a__nd_ *dog*")) - end - - def test_convert_attrs - str = '+foo+' - attrs = RDoc::Markup::AttrSpan.new str.length - - @am.convert_attrs str, attrs - - assert_equal "\000foo\000", str - - str = '+:foo:+' - attrs = RDoc::Markup::AttrSpan.new str.length - - @am.convert_attrs str, attrs - - assert_equal "\000:foo:\000", str - - str = '+x-y+' - attrs = RDoc::Markup::AttrSpan.new str.length - - @am.convert_attrs str, attrs - - assert_equal "\000x-y\000", str - end - - def test_html_like_em_bold - assert_equal ["cat ", @em_on, "and ", @em_to_bold, "dog", @bold_off], - @am.flow("cat <i>and </i><b>dog</b>") - end - - def test_html_like_em_bold_SGML - assert_equal ["cat ", @em_on, "and ", @em_to_bold, "dog", @bold_off], - @am.flow("cat <i>and <b></i>dog</b>") - end - - def test_html_like_em_bold_nested_1 - assert_equal(["cat ", @bold_em_on, "and", @bold_em_off, " dog"], - @am.flow("cat <i><b>and</b></i> dog")) - end - - def test_html_like_em_bold_nested_2 - assert_equal ["cat ", @em_on, "and ", @em_then_bold, "dog", @bold_em_off], - @am.flow("cat <i>and <b>dog</b></i>") - end - - def test_html_like_em_bold_nested_mixed_case - assert_equal ["cat ", @em_on, "and ", @em_then_bold, "dog", @bold_em_off], - @am.flow("cat <i>and <B>dog</B></I>") - end - - def test_html_like_em_bold_mixed_case - assert_equal ["cat ", @em_on, "and", @em_off, " ", @bold_on, "dog", @bold_off], - @am.flow("cat <i>and</i> <B>dog</b>") - end - - def test_html_like_teletype - assert_equal ["cat ", @tt_on, "dog", @tt_off], - @am.flow("cat <tt>dog</Tt>") - end - - def test_html_like_teletype_em_bold_SGML - assert_equal [@tt_on, "cat", @tt_off, " ", @em_on, "and ", @em_to_bold, "dog", @bold_off], - @am.flow("<tt>cat</tt> <i>and <b></i>dog</b>") - end - - def test_protect - assert_equal(['cat \\ dog'], @am.flow('cat \\ dog')) - - assert_equal(["cat <tt>dog</Tt>"], @am.flow("cat \\<tt>dog</Tt>")) - - assert_equal(["cat ", @em_on, "and", @em_off, " <B>dog</b>"], - @am.flow("cat <i>and</i> \\<B>dog</b>")) - - assert_equal(["*word* or <b>text</b>"], @am.flow("\\*word* or \\<b>text</b>")) - - assert_equal(["_cat_", @em_on, "dog", @em_off], - @am.flow("\\_cat_<i>dog</i>")) - end - - def test_special - @am.add_special(RDoc::Markup::ToHtmlCrossref::CROSSREF_REGEXP, :CROSSREF) - - # - # The apostrophes in "cats'" and "dogs'" suppress the flagging of these - # words as potential cross-references, which is necessary for the unit - # tests. Unfortunately, the markup engine right now does not actually - # check whether a cross-reference is valid before flagging it. - # - assert_equal(["cats'"], @am.flow("cats'")) - - assert_equal(["cats' ", crossref("#fred"), " dogs'"].flatten, - @am.flow("cats' #fred dogs'")) - - assert_equal([crossref("#fred"), " dogs'"].flatten, - @am.flow("#fred dogs'")) - - assert_equal(["cats' ", crossref("#fred")].flatten, @am.flow("cats' #fred")) - end - - def test_tt_html - assert_equal [@tt_on, '"\n"', @tt_off], - @am.flow('<tt>"\n"</tt>') - end - -end - -MiniTest::Unit.autorun diff --git a/vendor/gems/rdoc-2.4.3/test/test_rdoc_markup_to_html.rb b/vendor/gems/rdoc-2.4.3/test/test_rdoc_markup_to_html.rb deleted file mode 100644 index 5b8c09ccf..000000000 --- a/vendor/gems/rdoc-2.4.3/test/test_rdoc_markup_to_html.rb +++ /dev/null @@ -1,81 +0,0 @@ -require 'rubygems' -require 'minitest/unit' -require 'rdoc/markup' -require 'rdoc/markup/to_html' - -class TestRDocMarkupToHtml < MiniTest::Unit::TestCase - - def setup - @m = RDoc::Markup.new - @am = RDoc::Markup::AttributeManager.new - @th = RDoc::Markup::ToHtml.new - end - - def test_class_gen_relative_url - def gen(from, to) - RDoc::Markup::ToHtml.gen_relative_url from, to - end - - assert_equal 'a.html', gen('a.html', 'a.html') - assert_equal 'b.html', gen('a.html', 'b.html') - - assert_equal 'd.html', gen('a/c.html', 'a/d.html') - assert_equal '../a.html', gen('a/c.html', 'a.html') - assert_equal 'a/c.html', gen('a.html', 'a/c.html') - end - - def test_list_verbatim - str = "* one\n verb1\n verb2\n* two\n" - - expected = <<-EXPECTED -<ul> -<li>one - -<pre> - verb1 - verb2 -</pre> -</li> -<li>two - -</li> -</ul> - EXPECTED - - assert_equal expected, @m.convert(str, @th) - end - - def test_tt_formatting - assert_equal "<p>\n<tt>--</tt> — <tt>cats'</tt> cats’\n</p>\n", - util_format("<tt>--</tt> -- <tt>cats'</tt> cats'") - - assert_equal "<p>\n<b>—</b>\n</p>\n", util_format("<b>--</b>") - end - - def test_convert_string_fancy - # - # The HTML typesetting is broken in a number of ways, but I have fixed - # the most glaring issues for single and double quotes. Note that - # "strange" symbols (periods or dashes) need to be at the end of the - # test case strings in order to suppress cross-references. - # - assert_equal "<p>\n“cats”.\n</p>\n", util_format("\"cats\".") - assert_equal "<p>\n‘cats’.\n</p>\n", util_format("\'cats\'.") - assert_equal "<p>\ncat’s-\n</p>\n", util_format("cat\'s-") - end - - def util_fragment(text) - RDoc::Markup::Fragment.new 0, nil, nil, text - end - - def util_format(text) - fragment = util_fragment text - - @th.start_accepting - @th.accept_paragraph @am, fragment - @th.end_accepting - end - -end - -MiniTest::Unit.autorun diff --git a/vendor/gems/rdoc-2.4.3/test/test_rdoc_markup_to_html_crossref.rb b/vendor/gems/rdoc-2.4.3/test/test_rdoc_markup_to_html_crossref.rb deleted file mode 100644 index 9e77c4bdc..000000000 --- a/vendor/gems/rdoc-2.4.3/test/test_rdoc_markup_to_html_crossref.rb +++ /dev/null @@ -1,161 +0,0 @@ -require 'rubygems' -require 'minitest/unit' -require 'rdoc/rdoc' -require 'rdoc/code_objects' -require 'rdoc/markup/to_html_crossref' -require 'test/xref_test_case' - -class TestRDocMarkupToHtmlCrossref < XrefTestCase - - def setup - super - - @xref = RDoc::Markup::ToHtmlCrossref.new 'index.html', @c1, true - end - - def assert_ref(path, ref) - assert_equal "<p>\n<a href=\"#{path}\">#{ref}</a>\n</p>\n", - @xref.convert(ref) - end - - def refute_ref(body, ref) - assert_equal "<p>\n#{body}\n</p>\n", @xref.convert(ref) - end - - def test_handle_special_CROSSREF_C2 - @xref = RDoc::Markup::ToHtmlCrossref.new 'classes/C2.html', @c2, true - - refute_ref '#m', '#m' - - assert_ref '../C2/C3.html', 'C2::C3' - assert_ref '../C2/C3.html#M000002', 'C2::C3#m' - assert_ref '../C2/C3/H1.html', 'C3::H1' - assert_ref '../C4.html', 'C4' - - # TODO there is a C3::H2 in the top-level namespace and RDoc should follow - # constant scoping rules - refute_ref 'C3::H2', 'C3::H2' - refute_ref 'H1', 'H1' - end - - def test_handle_special_CROSSREF_C2_C3 - @xref = RDoc::Markup::ToHtmlCrossref.new 'classes/C2/C3.html', @c2_c3, true - - assert_ref '../../C2/C3.html#M000002', '#m' - - assert_ref '../../C2/C3.html', 'C3' - assert_ref '../../C2/C3.html#M000002', 'C3#m' - - assert_ref '../../C2/C3/H1.html', 'H1' - assert_ref '../../C2/C3/H1.html', 'C3::H1' - - assert_ref '../../C4.html', 'C4' - - refute_ref 'C3::H2', 'C3::H2' - end - - def test_handle_special_CROSSREF_C3 - @xref = RDoc::Markup::ToHtmlCrossref.new 'classes/C3.html', @c3, true - - assert_ref '../C3.html', 'C3' - - refute_ref '#m', '#m' - refute_ref 'C3#m', 'C3#m' - - assert_ref '../C3/H1.html', 'H1' - - assert_ref '../C3/H1.html', 'C3::H1' - assert_ref '../C3/H2.html', 'C3::H2' - - assert_ref '../C4.html', 'C4' - end - - def test_handle_special_CROSSREF_C4 - @xref = RDoc::Markup::ToHtmlCrossref.new 'classes/C4.html', @c4, true - - # C4 ref inside a C4 containing a C4 should resolve to the contained class - assert_ref '../C4/C4.html', 'C4' - end - - def test_handle_special_CROSSREF_C4_C4 - @xref = RDoc::Markup::ToHtmlCrossref.new 'classes/C4/C4.html', @c4_c4, true - - # A C4 reference inside a C4 class contained within a C4 class should - # resolve to the inner C4 class. - assert_ref '../../C4/C4.html', 'C4' - end - - def test_handle_special_CROSSREF_class - assert_ref 'C1.html', 'C1' - refute_ref 'H1', 'H1' - - assert_ref 'C2.html', 'C2' - assert_ref 'C2/C3.html', 'C2::C3' - assert_ref 'C2/C3/H1.html', 'C2::C3::H1' - - assert_ref 'C3.html', '::C3' - assert_ref 'C3/H1.html', '::C3::H1' - - assert_ref 'C4/C4.html', 'C4::C4' - end - - def test_handle_special_CROSSREF_file - assert_ref 'xref_data_rb.html', 'xref_data.rb' - end - - def test_handle_special_CROSSREF_method - refute_ref 'm', 'm' - assert_ref 'C1.html#M000000', '#m' - - assert_ref 'C1.html#M000000', 'C1#m' - assert_ref 'C1.html#M000000', 'C1#m()' - assert_ref 'C1.html#M000000', 'C1#m(*)' - - assert_ref 'C1.html#M000000', 'C1.m' - assert_ref 'C1.html#M000000', 'C1.m()' - assert_ref 'C1.html#M000000', 'C1.m(*)' - - # HACK should this work - #assert_ref 'classes/C1.html#M000001', 'C1::m' - #assert_ref 'classes/C1.html#M000001', 'C1::m()' - #assert_ref 'classes/C1.html#M000001', 'C1::m(*)' - - assert_ref 'C2/C3.html#M000002', 'C2::C3#m' - - assert_ref 'C2/C3.html#M000002', 'C2::C3.m' - - assert_ref 'C2/C3/H1.html#M000003', 'C2::C3::H1#m?' - - assert_ref 'C2/C3.html#M000002', '::C2::C3#m' - assert_ref 'C2/C3.html#M000002', '::C2::C3#m()' - assert_ref 'C2/C3.html#M000002', '::C2::C3#m(*)' - end - - def test_handle_special_CROSSREF_no_ref - assert_equal '', @xref.convert('') - - refute_ref 'bogus', 'bogus' - refute_ref 'bogus', '\bogus' - refute_ref '\bogus', '\\\bogus' - - refute_ref '#n', '\#n' - refute_ref '#n()', '\#n()' - refute_ref '#n(*)', '\#n(*)' - - refute_ref 'C1', '\C1' - refute_ref '::C3', '\::C3' - - refute_ref '::C3::H1#n', '::C3::H1#n' - refute_ref '::C3::H1#n(*)', '::C3::H1#n(*)' - refute_ref '::C3::H1#n', '\::C3::H1#n' - end - - def test_handle_special_CROSSREF_special - assert_equal "<p>\n<a href=\"C2/C3.html\">C2::C3</a>;method(*)\n</p>\n", - @xref.convert('C2::C3;method(*)') - end - -end - -MiniTest::Unit.autorun - diff --git a/vendor/gems/rdoc-2.4.3/test/test_rdoc_normal_module.rb b/vendor/gems/rdoc-2.4.3/test/test_rdoc_normal_module.rb deleted file mode 100644 index 9bd681954..000000000 --- a/vendor/gems/rdoc-2.4.3/test/test_rdoc_normal_module.rb +++ /dev/null @@ -1,26 +0,0 @@ -require 'test/xref_test_case' - -class TestRDocNormalModule < XrefTestCase - - def setup - super - - @mod = RDoc::NormalModule.new 'Mod' - end - - def test_comment_equals - @mod.comment = '# comment 1' - - assert_equal '# comment 1', @mod.comment - - @mod.comment = '# comment 2' - - assert_equal "# comment 1\n# ---\n# comment 2", @mod.comment - end - - def test_module_eh - assert @mod.module? - end - -end - diff --git a/vendor/gems/rdoc-2.4.3/test/test_rdoc_parser.rb b/vendor/gems/rdoc-2.4.3/test/test_rdoc_parser.rb deleted file mode 100644 index ae4801c42..000000000 --- a/vendor/gems/rdoc-2.4.3/test/test_rdoc_parser.rb +++ /dev/null @@ -1,29 +0,0 @@ -require 'rubygems' -require 'minitest/unit' -require 'rdoc/parser' -require 'rdoc/parser/ruby' - -class TestRDocParser < MiniTest::Unit::TestCase - def test_can_parse - assert_equal(RDoc::Parser.can_parse(__FILE__), RDoc::Parser::Ruby) - - readme_file_name = File.join(File.dirname(__FILE__), "..", "README.txt") - - unless File.exist? readme_file_name then # HACK for tests in trunk :/ - readme_file_name = File.join File.dirname(__FILE__), '..', '..', 'README' - end - - assert_equal(RDoc::Parser.can_parse(readme_file_name), RDoc::Parser::Simple) - - binary_file_name = File.join(File.dirname(__FILE__), "binary.dat") - assert_equal(RDoc::Parser.can_parse(binary_file_name), nil) - - jtest_file_name = File.join(File.dirname(__FILE__), "test.ja.txt") - assert_equal(RDoc::Parser::Simple, RDoc::Parser.can_parse(jtest_file_name)) - - jtest_rdoc_file_name = File.join(File.dirname(__FILE__), "test.ja.rdoc") - assert_equal(RDoc::Parser::Simple, RDoc::Parser.can_parse(jtest_rdoc_file_name)) - end -end - -MiniTest::Unit.autorun diff --git a/vendor/gems/rdoc-2.4.3/test/test_rdoc_parser_c.rb b/vendor/gems/rdoc-2.4.3/test/test_rdoc_parser_c.rb deleted file mode 100644 index 6d129cebe..000000000 --- a/vendor/gems/rdoc-2.4.3/test/test_rdoc_parser_c.rb +++ /dev/null @@ -1,401 +0,0 @@ -require 'stringio' -require 'tempfile' -require 'rubygems' -require 'minitest/unit' -require 'rdoc/options' -require 'rdoc/parser/c' - -class RDoc::Parser::C - attr_accessor :classes - - public :do_classes, :do_constants -end - -class TestRDocParserC < MiniTest::Unit::TestCase - - def setup - @tempfile = Tempfile.new self.class.name - filename = @tempfile.path - - @top_level = RDoc::TopLevel.new filename - @fn = filename - @options = RDoc::Options.new - @stats = RDoc::Stats.new 0 - - RDoc::Parser::C.reset - RDoc::TopLevel.reset - end - - def teardown - @tempfile.close - end - - def test_do_classes_boot_class - content = <<-EOF -/* Document-class: Foo - * this is the Foo boot class - */ -VALUE cFoo = boot_defclass("Foo", 0); - EOF - - klass = util_get_class content, 'cFoo' - assert_equal " this is the Foo boot class\n ", klass.comment - end - - def test_do_classes_class - content = <<-EOF -/* Document-class: Foo - * this is the Foo class - */ -VALUE cFoo = rb_define_class("Foo", rb_cObject); - EOF - - klass = util_get_class content, 'cFoo' - assert_equal " this is the Foo class\n ", klass.comment - end - - def test_do_classes_class_under - content = <<-EOF -/* Document-class: Kernel::Foo - * this is the Foo class under Kernel - */ -VALUE cFoo = rb_define_class_under(rb_mKernel, "Foo", rb_cObject); - EOF - - klass = util_get_class content, 'cFoo' - assert_equal " this is the Foo class under Kernel\n ", klass.comment - end - - def test_do_classes_module - content = <<-EOF -/* Document-module: Foo - * this is the Foo module - */ -VALUE mFoo = rb_define_module("Foo"); - EOF - - klass = util_get_class content, 'mFoo' - assert_equal " this is the Foo module\n ", klass.comment - end - - def test_do_classes_module_under - content = <<-EOF -/* Document-module: Kernel::Foo - * this is the Foo module under Kernel - */ -VALUE mFoo = rb_define_module_under(rb_mKernel, "Foo"); - EOF - - klass = util_get_class content, 'mFoo' - assert_equal " this is the Foo module under Kernel\n ", klass.comment - end - - def test_do_constants - content = <<-EOF -#include <ruby.h> - -void Init_foo(){ - VALUE cFoo = rb_define_class("Foo", rb_cObject); - - /* 300: The highest possible score in bowling */ - rb_define_const(cFoo, "PERFECT", INT2FIX(300)); - - /* Huzzah!: What you cheer when you roll a perfect game */ - rb_define_const(cFoo, "CHEER", rb_str_new2("Huzzah!")); - - /* TEST\:TEST: Checking to see if escaped semicolon works */ - rb_define_const(cFoo, "TEST", rb_str_new2("TEST:TEST")); - - /* \\: The file separator on MS Windows */ - rb_define_const(cFoo, "MSEPARATOR", rb_str_new2("\\")); - - /* /: The file separator on Unix */ - rb_define_const(cFoo, "SEPARATOR", rb_str_new2("/")); - - /* C:\\Program Files\\Stuff: A directory on MS Windows */ - rb_define_const(cFoo, "STUFF", rb_str_new2("C:\\Program Files\\Stuff")); - - /* Default definition */ - rb_define_const(cFoo, "NOSEMI", INT2FIX(99)); - - rb_define_const(cFoo, "NOCOMMENT", rb_str_new2("No comment")); - - /* - * Multiline comment goes here because this comment spans multiple lines. - * Multiline comment goes here because this comment spans multiple lines. - */ - rb_define_const(cFoo, "MULTILINE", INT2FIX(1)); - - /* - * 1: Multiline comment goes here because this comment spans multiple lines. - * Multiline comment goes here because this comment spans multiple lines. - */ - rb_define_const(cFoo, "MULTILINE_VALUE", INT2FIX(1)); - - /* Multiline comment goes here because this comment spans multiple lines. - * Multiline comment goes here because this comment spans multiple lines. - */ - rb_define_const(cFoo, "MULTILINE_NOT_EMPTY", INT2FIX(1)); - -} - EOF - - @parser = util_parser content - - @parser.do_classes - @parser.do_constants - - klass = @parser.classes['cFoo'] - assert klass - - constants = klass.constants - assert !klass.constants.empty? - - constants = constants.map { |c| [c.name, c.value, c.comment] } - - assert_equal ['PERFECT', '300', - "\n The highest possible score in bowling \n "], - constants.shift - assert_equal ['CHEER', 'Huzzah!', - "\n What you cheer when you roll a perfect game \n "], - constants.shift - assert_equal ['TEST', 'TEST:TEST', - "\n Checking to see if escaped semicolon works \n "], - constants.shift - assert_equal ['MSEPARATOR', '\\', - "\n The file separator on MS Windows \n "], - constants.shift - assert_equal ['SEPARATOR', '/', - "\n The file separator on Unix \n "], - constants.shift - assert_equal ['STUFF', 'C:\\Program Files\\Stuff', - "\n A directory on MS Windows \n "], - constants.shift - assert_equal ['NOSEMI', 'INT2FIX(99)', - "\n Default definition \n "], - constants.shift - assert_equal ['NOCOMMENT', 'rb_str_new2("No comment")', nil], - constants.shift - - comment = <<-EOF.chomp - - - Multiline comment goes here because this comment spans multiple lines. - Multiline comment goes here because this comment spans multiple lines. - - - EOF - assert_equal ['MULTILINE', 'INT2FIX(1)', comment], constants.shift - assert_equal ['MULTILINE_VALUE', '1', comment], constants.shift - - comment = <<-EOF.chomp - - Multiline comment goes here because this comment spans multiple lines. - Multiline comment goes here because this comment spans multiple lines. - - - EOF - assert_equal ['MULTILINE_NOT_EMPTY', 'INT2FIX(1)', comment], constants.shift - - assert constants.empty?, constants.inspect - end - - def test_find_class_comment_init - content = <<-EOF -/* - * a comment for class Foo - */ -void -Init_Foo(void) { - VALUE foo = rb_define_class("Foo", rb_cObject); -} - EOF - - klass = util_get_class content, 'foo' - - assert_equal " \n a comment for class Foo\n \n", klass.comment - end - - def test_find_class_comment_define_class - content = <<-EOF -/* - * a comment for class Foo - */ -VALUE foo = rb_define_class("Foo", rb_cObject); - EOF - - klass = util_get_class content, 'foo' - - assert_equal " \n a comment for class Foo\n \n", klass.comment - end - - def test_find_class_comment_define_class_Init_Foo - content = <<-EOF -/* - * a comment for class Foo on Init - */ -void -Init_Foo(void) { - /* - * a comment for class Foo on rb_define_class - */ - VALUE foo = rb_define_class("Foo", rb_cObject); -} - EOF - - klass = util_get_class content, 'foo' - - assert_equal " \n a comment for class Foo on Init\n \n", klass.comment - end - - def test_find_class_comment_define_class_bogus_comment - content = <<-EOF -/* - * a comment for other_function - */ -void -other_function() { -} - -void -Init_Foo(void) { - VALUE foo = rb_define_class("Foo", rb_cObject); -} - EOF - - klass = util_get_class content, 'foo' - - assert_equal '', klass.comment - end - - def test_find_body - content = <<-EOF -/* - * a comment for other_function - */ -VALUE -other_function() { -} - -void -Init_Foo(void) { - VALUE foo = rb_define_class("Foo", rb_cObject); - - rb_define_method(foo, "my_method", other_function, 0); -} - EOF - - klass = util_get_class content, 'foo' - other_function = klass.method_list.first - - assert_equal 'my_method', other_function.name - assert_equal " \n a comment for other_function\n \n", - other_function.comment - assert_equal '()', other_function.params - - code = other_function.token_stream.first.text - - assert_equal "VALUE\nother_function() ", code - end - - def test_find_body_define - content = <<-EOF -/* - * a comment for other_function - */ -#define other_function rb_other_function - -/* */ -VALUE -rb_other_function() { -} - -void -Init_Foo(void) { - VALUE foo = rb_define_class("Foo", rb_cObject); - - rb_define_method(foo, "my_method", other_function, 0); -} - EOF - - klass = util_get_class content, 'foo' - other_function = klass.method_list.first - - assert_equal 'my_method', other_function.name - assert_equal " \n a comment for other_function\n \n \n", - other_function.comment - assert_equal '()', other_function.params - - code = other_function.token_stream.first.text - - assert_equal "#define other_function rb_other_function", code - end - - def test_define_method - content = <<-EOF -/*Method Comment! */ -static VALUE -rb_io_s_read(argc, argv, io) - int argc; - VALUE *argv; - VALUE io; -{ -} - -void -Init_IO(void) { - /* - * a comment for class Foo on rb_define_class - */ - VALUE rb_cIO = rb_define_class("IO", rb_cObject); - rb_define_singleton_method(rb_cIO, "read", rb_io_s_read, -1); -} - EOF - - klass = util_get_class content, 'rb_cIO' - read_method = klass.method_list.first - assert_equal "read", read_method.name - assert_equal " Method Comment! \n", read_method.comment - end - - def test_define_method_private - content = <<-EOF -/*Method Comment! */ -static VALUE -rb_io_s_read(argc, argv, io) - int argc; - VALUE *argv; - VALUE io; -{ -} - -void -Init_IO(void) { - /* - * a comment for class Foo on rb_define_class - */ - VALUE rb_cIO = rb_define_class("IO", rb_cObject); - rb_define_private_method(rb_cIO, "read", rb_io_s_read, -1); -} - EOF - - klass = util_get_class content, 'rb_cIO' - read_method = klass.method_list.first - assert_equal 'IO#read', read_method.full_name - assert_equal :private, read_method.visibility - assert_equal " Method Comment! \n", read_method.comment - end - - def util_get_class(content, name) - @parser = util_parser content - @parser.scan - @parser.classes[name] - end - - def util_parser(content) - RDoc::Parser::C.new @top_level, @fn, content, @options, @stats - end - -end - -MiniTest::Unit.autorun diff --git a/vendor/gems/rdoc-2.4.3/test/test_rdoc_parser_perl.rb b/vendor/gems/rdoc-2.4.3/test/test_rdoc_parser_perl.rb deleted file mode 100644 index 165cadaa5..000000000 --- a/vendor/gems/rdoc-2.4.3/test/test_rdoc_parser_perl.rb +++ /dev/null @@ -1,74 +0,0 @@ -require 'stringio' -require 'tempfile' -require 'rubygems' -require 'minitest/unit' -require 'rdoc/options' -require 'rdoc/parser/perl' - -class TestRdocParserPerlPOD < MiniTest::Unit::TestCase - - def setup - @tempfile = Tempfile.new self.class.name - filename = @tempfile.path - - @top_level = RDoc::TopLevel.new filename - @fn = filename - @options = RDoc::Options.new - @stats = RDoc::Stats.new 0 - end - - def teardown - @tempfile.close - end - - def test_uncommented_perl - content = <<-EOF -while (<>) { - tr/a-z/A-Z; - print -} - EOF - - comment = util_get_comment content - assert_equal "", comment - end - - def test_perl_without_pod - content = <<-EOF -#!/usr/local/bin/perl -# -#This is a pointless perl program because it does -p. -# -while(<>) {print;}: - EOF - - comment = util_get_comment content - assert_equal "", comment - end - - def test_simple_pod_no_structure - content = <<-EOF -=begin pod - -This just contains plain old documentation - -=end - EOF - comment = util_get_comment content - assert_equal "\nThis just contains plain old documentation\n\n", comment - end - - # Get the comment of the @top_level when it has processed the input. - def util_get_comment(content) - parser = util_parser content - parser.scan.comment - end - - # create a new parser with the supplied content. - def util_parser(content) - RDoc::Parser::PerlPOD.new @top_level, @fn, content, @options, @stats - end - -end - -MiniTest::Unit.autorun diff --git a/vendor/gems/rdoc-2.4.3/test/test_rdoc_parser_ruby.rb b/vendor/gems/rdoc-2.4.3/test/test_rdoc_parser_ruby.rb deleted file mode 100644 index 5fb880cb3..000000000 --- a/vendor/gems/rdoc-2.4.3/test/test_rdoc_parser_ruby.rb +++ /dev/null @@ -1,1040 +0,0 @@ -require 'stringio' -require 'tempfile' -require 'rubygems' -require 'minitest/autorun' - -require 'rdoc/options' -require 'rdoc/parser/ruby' -require 'rdoc/stats' - -class TestRDocParserRuby < MiniTest::Unit::TestCase - - def setup - @tempfile = Tempfile.new self.class.name - @filename = @tempfile.path - - # Some tests need two paths. - @tempfile2 = Tempfile.new self.class.name - @filename2 = @tempfile2.path - - util_top_level - @options = RDoc::Options.new - @options.quiet = true - @stats = RDoc::Stats.new 0 - end - - def teardown - @tempfile.close - @tempfile2.close - end - - def test_look_for_directives_in_attr - util_parser "" - - comment = "# :attr: my_attr\n" - - @parser.look_for_directives_in @top_level, comment - - assert_equal "# :attr: my_attr\n", comment - - comment = "# :attr_reader: my_method\n" - - @parser.look_for_directives_in @top_level, comment - - assert_equal "# :attr_reader: my_method\n", comment - - comment = "# :attr_writer: my_method\n" - - @parser.look_for_directives_in @top_level, comment - - assert_equal "# :attr_writer: my_method\n", comment - end - - def test_look_for_directives_in_commented - util_parser "" - - comment = "# how to make a section:\n# # :section: new section\n" - - @parser.look_for_directives_in @top_level, comment - - section = @top_level.current_section - assert_equal nil, section.title - assert_equal nil, section.comment - - assert_equal "# how to make a section:\n# # :section: new section\n", - comment - end - - def test_look_for_directives_in_enddoc - util_parser "" - - assert_throws :enddoc do - @parser.look_for_directives_in @top_level, "# :enddoc:\n" - end - end - - def test_look_for_directives_in_main - util_parser "" - - @parser.look_for_directives_in @top_level, "# :main: new main page\n" - - assert_equal 'new main page', @options.main_page - end - - def test_look_for_directives_in_method - util_parser "" - - comment = "# :method: my_method\n" - - @parser.look_for_directives_in @top_level, comment - - assert_equal "# :method: my_method\n", comment - - comment = "# :singleton-method: my_method\n" - - @parser.look_for_directives_in @top_level, comment - - assert_equal "# :singleton-method: my_method\n", comment - end - - def test_look_for_directives_in_startdoc - util_parser "" - - @top_level.stop_doc - assert !@top_level.document_self - assert !@top_level.document_children - assert !@top_level.force_documentation - - @parser.look_for_directives_in @top_level, "# :startdoc:\n" - - assert @top_level.document_self - assert @top_level.document_children - assert @top_level.force_documentation - end - - def test_look_for_directives_in_stopdoc - util_parser "" - - assert @top_level.document_self - assert @top_level.document_children - - @parser.look_for_directives_in @top_level, "# :stopdoc:\n" - - assert !@top_level.document_self - assert !@top_level.document_children - end - - def test_look_for_directives_in_section - util_parser "" - - comment = "# :section: new section\n# woo stuff\n" - - @parser.look_for_directives_in @top_level, comment - - section = @top_level.current_section - assert_equal 'new section', section.title - assert_equal "# woo stuff\n", section.comment - - assert_equal '', comment - end - - def test_look_for_directives_in_title - util_parser "" - - @parser.look_for_directives_in @top_level, "# :title: new title\n" - - assert_equal 'new title', @options.title - end - - def test_look_for_directives_in_unhandled - util_parser "" - - comment = "# :unhandled: \n# :title: hi\n" - - @parser.look_for_directives_in @top_level, comment - - assert_equal "# :unhandled: \n", comment - - assert_equal 'hi', @options.title - end - - def test_parse_attr - klass = RDoc::NormalClass.new 'Foo' - klass.parent = @top_level - - comment = "##\n# my attr\n" - - util_parser "attr :foo, :bar" - - tk = @parser.get_tk - - @parser.parse_attr klass, RDoc::Parser::Ruby::NORMAL, tk, comment - - assert_equal 1, klass.attributes.length - - foo = klass.attributes.first - assert_equal 'foo', foo.name - assert_equal "##\n# my attr\n", foo.comment - end - - def test_parse_attr_accessor - klass = RDoc::NormalClass.new 'Foo' - klass.parent = @top_level - - comment = "##\n# my attr\n" - - util_parser "attr_accessor :foo, :bar" - - tk = @parser.get_tk - - @parser.parse_attr_accessor klass, RDoc::Parser::Ruby::NORMAL, tk, comment - - assert_equal 2, klass.attributes.length - - foo = klass.attributes.first - assert_equal 'foo', foo.name - assert_equal 'RW', foo.rw - assert_equal "##\n# my attr\n", foo.comment - - bar = klass.attributes.last - assert_equal 'bar', bar.name - assert_equal 'RW', bar.rw - assert_equal "##\n# my attr\n", bar.comment - end - - def test_parse_attr_accessor_writer - klass = RDoc::NormalClass.new 'Foo' - klass.parent = @top_level - - comment = "##\n# my attr\n" - - util_parser "attr_writer :foo, :bar" - - tk = @parser.get_tk - - @parser.parse_attr_accessor klass, RDoc::Parser::Ruby::NORMAL, tk, comment - - assert_equal 2, klass.attributes.length - - foo = klass.attributes.first - assert_equal 'foo', foo.name - assert_equal 'W', foo.rw - assert_equal "##\n# my attr\n", foo.comment - - bar = klass.attributes.last - assert_equal 'bar', bar.name - assert_equal 'W', bar.rw - assert_equal "##\n# my attr\n", bar.comment - end - - def test_parse_meta_attr - klass = RDoc::NormalClass.new 'Foo' - klass.parent = @top_level - - comment = "##\n# :attr: \n# my method\n" - - util_parser "add_my_method :foo, :bar" - - tk = @parser.get_tk - - @parser.parse_meta_attr klass, RDoc::Parser::Ruby::NORMAL, tk, comment - - foo = klass.attributes.first - assert_equal 'foo', foo.name - assert_equal 'RW', foo.rw - assert_equal "##\n# my method\n", foo.comment - end - - def test_parse_meta_attr_accessor - klass = RDoc::NormalClass.new 'Foo' - klass.parent = @top_level - - comment = "##\n# :attr_accessor: \n# my method\n" - - util_parser "add_my_method :foo, :bar" - - tk = @parser.get_tk - - @parser.parse_meta_attr klass, RDoc::Parser::Ruby::NORMAL, tk, comment - - foo = klass.attributes.first - assert_equal 'foo', foo.name - assert_equal 'RW', foo.rw - assert_equal "##\n# my method\n", foo.comment - end - - def test_parse_meta_attr_reader - klass = RDoc::NormalClass.new 'Foo' - klass.parent = @top_level - - comment = "##\n# :attr_reader: \n# my method\n" - - util_parser "add_my_method :foo, :bar" - - tk = @parser.get_tk - - @parser.parse_meta_attr klass, RDoc::Parser::Ruby::NORMAL, tk, comment - - foo = klass.attributes.first - assert_equal 'foo', foo.name - assert_equal 'R', foo.rw - assert_equal "##\n# my method\n", foo.comment - end - - def test_parse_meta_attr_writer - klass = RDoc::NormalClass.new 'Foo' - klass.parent = @top_level - - comment = "##\n# :attr_writer: \n# my method\n" - - util_parser "add_my_method :foo, :bar" - - tk = @parser.get_tk - - @parser.parse_meta_attr klass, RDoc::Parser::Ruby::NORMAL, tk, comment - - foo = klass.attributes.first - assert_equal 'foo', foo.name - assert_equal 'W', foo.rw - assert_equal "##\n# my method\n", foo.comment - end - - def test_parse_class - comment = "##\n# my method\n" - - util_parser 'class Foo; end' - - tk = @parser.get_tk - - @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, comment - - foo = @top_level.classes.first - assert_equal 'Foo', foo.full_name - assert_equal comment, foo.comment - end - - def test_parse_class_nested_superclass - foo = RDoc::NormalModule.new 'Foo' - foo.parent = @top_level - - util_parser "class Bar < Super\nend" - - tk = @parser.get_tk - - @parser.parse_class foo, RDoc::Parser::Ruby::NORMAL, tk, '' - - bar = foo.classes.first - assert_equal 'Super', bar.superclass - end - - def test_parse_module - comment = "##\n# my module\n" - - util_parser 'module Foo; end' - - tk = @parser.get_tk - - @parser.parse_module @top_level, RDoc::Parser::Ruby::NORMAL, tk, comment - - foo = @top_level.modules.first - assert_equal 'Foo', foo.full_name - assert_equal comment, foo.comment - end - - def test_parse_class_mistaken_for_module - # The code below is not strictly legal Ruby (Foo must have been defined - # before Foo::Bar is encountered), but RDoc might encounter Foo::Bar - # before Foo if they live in different files. - - code = <<-EOF -class Foo::Bar -end - -module Foo::Baz -end - -class Foo -end - EOF - - util_parser code - - @parser.scan - - assert_equal %w[Foo::Baz], RDoc::TopLevel.modules_hash.keys - assert_empty @top_level.modules - - foo = @top_level.classes.first - assert_equal 'Foo', foo.full_name - - bar = foo.classes.first - assert_equal 'Foo::Bar', bar.full_name - - baz = foo.modules.first - assert_equal 'Foo::Baz', baz.full_name - end - - def test_parse_class_definition_encountered_after_class_reference - # The code below is not strictly legal Ruby (Foo must have been defined - # before Foo.bar is encountered), but RDoc might encounter Foo.bar before - # Foo if they live in different files. - - code = <<-EOF -def Foo.bar -end - -class Foo < IO -end - EOF - - util_parser code - - @parser.scan - - assert_empty RDoc::TopLevel.modules_hash - # HACK why does it fail? - #assert_empty @top_level.modules - - foo = @top_level.classes.first - assert_equal 'Foo', foo.full_name - assert_equal 'IO', foo.superclass - - bar = foo.method_list.first - assert_equal 'bar', bar.name - end - - def test_parse_module_relative_to_top_level_namespace - comment = <<-EOF -# -# Weirdly named module -# -EOF - - code = comment + <<-EOF -module ::Foo - class Helper - end -end -EOF - - util_parser code - @parser.scan() - - foo = @top_level.modules.first - assert_equal 'Foo', foo.full_name - assert_equal comment, foo.comment - - helper = foo.classes.first - assert_equal 'Foo::Helper', helper.full_name - end - - def test_parse_comment_attr - klass = RDoc::NormalClass.new 'Foo' - klass.parent = @top_level - - comment = "##\n# :attr: foo\n# my attr\n" - - util_parser "\n" - - tk = @parser.get_tk - - @parser.parse_comment klass, tk, comment - - foo = klass.attributes.first - assert_equal 'foo', foo.name - assert_equal 'RW', foo.rw - assert_equal comment, foo.comment - - assert_equal nil, foo.viewer - assert_equal true, foo.document_children - assert_equal true, foo.document_self - assert_equal false, foo.done_documenting - assert_equal false, foo.force_documentation - assert_equal klass, foo.parent - assert_equal :public, foo.visibility - assert_equal "\n", foo.text - assert_equal klass.current_section, foo.section - end - - def test_parse_comment_method - klass = RDoc::NormalClass.new 'Foo' - klass.parent = @top_level - - comment = "##\n# :method: foo\n# my method\n" - - util_parser "\n" - - tk = @parser.get_tk - - @parser.parse_comment klass, tk, comment - - foo = klass.method_list.first - assert_equal 'foo', foo.name - assert_equal comment, foo.comment - - assert_equal [], foo.aliases - assert_equal nil, foo.block_params - assert_equal nil, foo.call_seq - assert_equal nil, foo.is_alias_for - assert_equal nil, foo.viewer - assert_equal true, foo.document_children - assert_equal true, foo.document_self - assert_equal '', foo.params - assert_equal false, foo.done_documenting - assert_equal false, foo.dont_rename_initialize - assert_equal false, foo.force_documentation - assert_equal klass, foo.parent - assert_equal false, foo.singleton - assert_equal :public, foo.visibility - assert_equal "\n", foo.text - assert_equal klass.current_section, foo.section - - stream = [ - tk(:COMMENT, 1, 1, nil, "# File #{@top_level.absolute_name}, line 1"), - RDoc::Parser::Ruby::NEWLINE_TOKEN, - tk(:SPACE, 1, 1, nil, ''), - ] - - assert_equal stream, foo.token_stream - end - - def test_parse_meta_method - klass = RDoc::NormalClass.new 'Foo' - klass.parent = @top_level - - comment = "##\n# my method\n" - - util_parser "add_my_method :foo, :bar\nadd_my_method :baz" - - tk = @parser.get_tk - - @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment - - foo = klass.method_list.first - assert_equal 'foo', foo.name - assert_equal comment, foo.comment - - assert_equal [], foo.aliases - assert_equal nil, foo.block_params - assert_equal nil, foo.call_seq - assert_equal true, foo.document_children - assert_equal true, foo.document_self - assert_equal false, foo.done_documenting - assert_equal false, foo.dont_rename_initialize - assert_equal false, foo.force_documentation - assert_equal nil, foo.is_alias_for - assert_equal '', foo.params - assert_equal klass, foo.parent - assert_equal false, foo.singleton - assert_equal 'add_my_method :foo', foo.text - assert_equal nil, foo.viewer - assert_equal :public, foo.visibility - assert_equal klass.current_section, foo.section - - stream = [ - tk(:COMMENT, 1, 1, nil, "# File #{@top_level.absolute_name}, line 1"), - RDoc::Parser::Ruby::NEWLINE_TOKEN, - tk(:SPACE, 1, 1, nil, ''), - tk(:IDENTIFIER, 1, 0, 'add_my_method', 'add_my_method'), - tk(:SPACE, 1, 13, nil, ' '), - tk(:SYMBOL, 1, 14, nil, ':foo'), - tk(:COMMA, 1, 18, nil, ','), - tk(:SPACE, 1, 19, nil, ' '), - tk(:SYMBOL, 1, 20, nil, ':bar'), - tk(:NL, 1, 24, nil, "\n"), - ] - - assert_equal stream, foo.token_stream - end - - def test_parse_meta_method_name - klass = RDoc::NormalClass.new 'Foo' - klass.parent = @top_level - - comment = "##\n# :method: woo_hoo!\n# my method\n" - - util_parser "add_my_method :foo, :bar\nadd_my_method :baz" - - tk = @parser.get_tk - - @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment - - foo = klass.method_list.first - assert_equal 'woo_hoo!', foo.name - assert_equal "##\n# my method\n", foo.comment - end - - def test_parse_meta_method_singleton - klass = RDoc::NormalClass.new 'Foo' - klass.parent = @top_level - - comment = "##\n# :singleton-method:\n# my method\n" - - util_parser "add_my_method :foo, :bar\nadd_my_method :baz" - - tk = @parser.get_tk - - @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment - - foo = klass.method_list.first - assert_equal 'foo', foo.name - assert_equal true, foo.singleton, 'singleton method' - assert_equal "##\n# my method\n", foo.comment - end - - def test_parse_meta_method_singleton_name - klass = RDoc::NormalClass.new 'Foo' - klass.parent = @top_level - - comment = "##\n# :singleton-method: woo_hoo!\n# my method\n" - - util_parser "add_my_method :foo, :bar\nadd_my_method :baz" - - tk = @parser.get_tk - - @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment - - foo = klass.method_list.first - assert_equal 'woo_hoo!', foo.name - assert_equal true, foo.singleton, 'singleton method' - assert_equal "##\n# my method\n", foo.comment - end - - def test_parse_meta_method_string_name - klass = RDoc::NormalClass.new 'Foo' - comment = "##\n# my method\n" - - util_parser "add_my_method 'foo'" - - tk = @parser.get_tk - - @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment - - foo = klass.method_list.first - assert_equal 'foo', foo.name - assert_equal comment, foo.comment - end - - def test_parse_meta_method_unknown - klass = RDoc::NormalClass.new 'Foo' - comment = "##\n# my method\n" - - util_parser "add_my_method ('foo')" - - tk = @parser.get_tk - - @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment - - foo = klass.method_list.first - assert_equal 'unknown', foo.name - assert_equal comment, foo.comment - end - - def test_parse_method - klass = RDoc::NormalClass.new 'Foo' - klass.parent = @top_level - - comment = "##\n# my method\n" - - util_parser "def foo() :bar end" - - tk = @parser.get_tk - - @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment - - foo = klass.method_list.first - assert_equal 'foo', foo.name - assert_equal comment, foo.comment - - assert_equal [], foo.aliases - assert_equal nil, foo.block_params - assert_equal nil, foo.call_seq - assert_equal nil, foo.is_alias_for - assert_equal nil, foo.viewer - assert_equal true, foo.document_children - assert_equal true, foo.document_self - assert_equal '()', foo.params - assert_equal false, foo.done_documenting - assert_equal false, foo.dont_rename_initialize - assert_equal false, foo.force_documentation - assert_equal klass, foo.parent - assert_equal false, foo.singleton - assert_equal :public, foo.visibility - assert_equal 'def foo', foo.text - assert_equal klass.current_section, foo.section - - stream = [ - tk(:COMMENT, 1, 1, nil, "# File #{@top_level.absolute_name}, line 1"), - RDoc::Parser::Ruby::NEWLINE_TOKEN, - tk(:SPACE, 1, 1, nil, ''), - tk(:DEF, 1, 0, 'def', 'def'), - tk(:SPACE, 1, 3, nil, ' '), - tk(:IDENTIFIER, 1, 4, 'foo', 'foo'), - tk(:LPAREN, 1, 7, nil, '('), - tk(:RPAREN, 1, 8, nil, ')'), - tk(:SPACE, 1, 9, nil, ' '), - tk(:COLON, 1, 10, nil, ':'), - tk(:IDENTIFIER, 1, 11, 'bar', 'bar'), - tk(:SPACE, 1, 14, nil, ' '), - tk(:END, 1, 15, 'end', 'end'), - ] - - assert_equal stream, foo.token_stream - end - - def test_parse_method_funky - klass = RDoc::NormalClass.new 'Foo' - klass.parent = @top_level - - comment = "##\n# my method\n" - - util_parser "def (blah).foo() :bar end" - - tk = @parser.get_tk - - @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment - - assert klass.method_list.empty? - end - - def test_parse_method_no_parens - klass = RDoc::NormalClass.new 'Foo' - klass.parent = @top_level - - comment = "##\n# my method\n" - - util_parser "def foo arg1, arg2\nend" - - tk = @parser.get_tk - - @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment - - foo = klass.method_list.first - assert_equal '(arg1, arg2)', foo.params - end - - def test_parse_method_parameters_comment - klass = RDoc::NormalClass.new 'Foo' - klass.parent = @top_level - - comment = "##\n# my method\n" - - util_parser "def foo arg1, arg2 # some useful comment\nend" - - tk = @parser.get_tk - - @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment - - foo = klass.method_list.first - assert_equal '(arg1, arg2)', foo.params - end - - def test_parse_method_parameters_comment_continue - klass = RDoc::NormalClass.new 'Foo' - klass.parent = @top_level - - comment = "##\n# my method\n" - - util_parser "def foo arg1, arg2, # some useful comment\narg3\nend" - - tk = @parser.get_tk - - @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment - - foo = klass.method_list.first - assert_equal '(arg1, arg2, arg3)', foo.params - end - - def test_parse_method_toplevel - klass = @top_level - - comment = "##\n# my method\n" - - util_parser "def foo arg1, arg2\nend" - - tk = @parser.get_tk - - @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment - - object = RDoc::TopLevel.find_class_named 'Object' - - foo = object.method_list.first - assert_equal 'Object#foo', foo.full_name - end - - def test_parse_statements_class_if - comment = "##\n# my method\n" - - util_parser <<-CODE -module Foo - X = if TRUE then - '' - end - - def blah - end -end - CODE - - @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil, '' - - foo = @top_level.modules.first - assert_equal 'Foo', foo.full_name, 'module Foo' - - methods = foo.method_list - assert_equal 1, methods.length - assert_equal 'Foo#blah', methods.first.full_name - end - - def test_parse_statements_class_nested - comment = "##\n# my method\n" - - util_parser "module Foo\n#{comment}class Bar\nend\nend" - - @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil, '' - - foo = @top_level.modules.first - assert_equal 'Foo', foo.full_name, 'module Foo' - - bar = foo.classes.first - assert_equal 'Foo::Bar', bar.full_name, 'class Foo::Bar' - assert_equal comment, bar.comment - end - - def test_parse_statements_identifier_meta_method - content = <<-EOF -class Foo - ## - # this is my method - add_my_method :foo -end - EOF - - util_parser content - - @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil, '' - - foo = @top_level.classes.first.method_list.first - assert_equal 'foo', foo.name - end - - def test_parse_statements_identifier_alias_method - content = "class Foo def foo() end; alias_method :foo2, :foo end" - - util_parser content - - @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil, '' - - foo = @top_level.classes.first.method_list[0] - assert_equal 'foo', foo.name - - foo2 = @top_level.classes.first.method_list.last - assert_equal 'foo2', foo2.name - assert_equal 'foo', foo2.is_alias_for.name - assert @top_level.classes.first.aliases.empty? - end - - def test_parse_statements_identifier_alias_method_before_original_method - # This is not strictly legal Ruby code, but it simulates finding an alias - # for a method before finding the original method, which might happen - # to rdoc if the alias is in a different file than the original method - # and rdoc processes the alias' file first. - content = <<-EOF -class Foo - alias_method :foo2, :foo - - alias_method :foo3, :foo - - def foo() - end - - alias_method :foo4, :foo - - alias_method :foo5, :unknown -end -EOF - - util_parser content - - @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil, '' - - foo = @top_level.classes.first.method_list[0] - assert_equal 'foo', foo.name - - foo2 = @top_level.classes.first.method_list[1] - assert_equal 'foo2', foo2.name - assert_equal 'foo', foo2.is_alias_for.name - - foo3 = @top_level.classes.first.method_list[2] - assert_equal 'foo3', foo3.name - assert_equal 'foo', foo3.is_alias_for.name - - foo4 = @top_level.classes.first.method_list.last - assert_equal 'foo4', foo4.name - assert_equal 'foo', foo4.is_alias_for.name - - assert_equal 'unknown', @top_level.classes.first.aliases[0].old_name - end - - def test_parse_statements_identifier_constant - content = <<-EOF -class Foo - FIRST_CONSTANT = 5 - - SECOND_CONSTANT = [ - 1, - 2, - 3 - ] - - THIRD_CONSTANT = { - :foo => 'bar', - :x => 'y' - } - - FOURTH_CONSTANT = SECOND_CONSTANT.map do |element| - element + 1 - element + 2 - end - - FIFTH_CONSTANT = SECOND_CONSTANT.map { |element| element + 1 } -end -EOF - - util_parser content - - @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil, '' - - constants = @top_level.classes.first.constants - - constant = constants[0] - assert_equal 'FIRST_CONSTANT', constant.name - assert_equal '5', constant.value - - constant = constants[1] - assert_equal 'SECOND_CONSTANT', constant.name - assert_equal '[ 1, 2, 3 ]', constant.value - - constant = constants[2] - assert_equal 'THIRD_CONSTANT', constant.name - assert_equal "{ :foo => 'bar', :x => 'y' }", constant.value - - constant = constants[3] - assert_equal 'FOURTH_CONSTANT', constant.name - assert_equal 'SECOND_CONSTANT.map do |element| element + 1 element + 2 end', constant.value - - constant = constants.last - assert_equal 'FIFTH_CONSTANT', constant.name - assert_equal 'SECOND_CONSTANT.map { |element| element + 1 }', constant.value - end - - def test_parse_statements_identifier_attr - content = "class Foo; attr :foo; end" - - util_parser content - - @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil, '' - - foo = @top_level.classes.first.attributes.first - assert_equal 'foo', foo.name - assert_equal 'R', foo.rw - end - - def test_parse_statements_identifier_attr_accessor - content = "class Foo; attr_accessor :foo; end" - - util_parser content - - @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil, '' - - foo = @top_level.classes.first.attributes.first - assert_equal 'foo', foo.name - assert_equal 'RW', foo.rw - end - - def test_parse_statements_identifier_include - content = "class Foo; include Bar; end" - - util_parser content - - @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil, '' - - foo = @top_level.classes.first - assert_equal 'Foo', foo.name - assert_equal 1, foo.includes.length - end - - def test_parse_statements_identifier_module_function - content = "module Foo def foo() end; module_function :foo; end" - - util_parser content - - @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil, '' - - foo, s_foo = @top_level.modules.first.method_list - assert_equal 'foo', foo.name, 'instance method name' - assert_equal :private, foo.visibility, 'instance method visibility' - assert_equal false, foo.singleton, 'instance method singleton' - - assert_equal 'foo', s_foo.name, 'module function name' - assert_equal :public, s_foo.visibility, 'module function visibility' - assert_equal true, s_foo.singleton, 'module function singleton' - end - - def test_parse_statements_identifier_private - content = "class Foo private; def foo() end end" - - util_parser content - - @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil, '' - - foo = @top_level.classes.first.method_list.first - assert_equal 'foo', foo.name - assert_equal :private, foo.visibility - end - - def test_parse_statements_identifier_require - content = "require 'bar'" - - util_parser content - - @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil, '' - - assert_equal 1, @top_level.requires.length - end - - def tk(klass, line, char, name, text) - klass = RDoc::RubyToken.const_get "Tk#{klass.to_s.upcase}" - - token = if klass.instance_method(:initialize).arity == 2 then - raise ArgumentError, "name not used for #{klass}" unless name.nil? - klass.new line, char - else - klass.new line, char, name - end - - token.set_text text - - token - end - - def util_parser(content) - @parser = RDoc::Parser::Ruby.new @top_level, @filename, content, @options, - @stats - end - - def util_two_parsers(first_file_content, second_file_content) - util_parser first_file_content - - @parser2 = RDoc::Parser::Ruby.new @top_level2, @filename, - second_file_content, @options, @stats - end - - def util_top_level - RDoc::TopLevel.reset - @top_level = RDoc::TopLevel.new @filename - @top_level2 = RDoc::TopLevel.new @filename2 - end - -end - diff --git a/vendor/gems/rdoc-2.4.3/test/test_rdoc_require.rb b/vendor/gems/rdoc-2.4.3/test/test_rdoc_require.rb deleted file mode 100644 index d5850bd16..000000000 --- a/vendor/gems/rdoc-2.4.3/test/test_rdoc_require.rb +++ /dev/null @@ -1,25 +0,0 @@ -require 'test/xref_test_case' - -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 - diff --git a/vendor/gems/rdoc-2.4.3/test/test_rdoc_ri_attribute_formatter.rb b/vendor/gems/rdoc-2.4.3/test/test_rdoc_ri_attribute_formatter.rb deleted file mode 100644 index a86312618..000000000 --- a/vendor/gems/rdoc-2.4.3/test/test_rdoc_ri_attribute_formatter.rb +++ /dev/null @@ -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 diff --git a/vendor/gems/rdoc-2.4.3/test/test_rdoc_ri_default_display.rb b/vendor/gems/rdoc-2.4.3/test/test_rdoc_ri_default_display.rb deleted file mode 100644 index 54b900642..000000000 --- a/vendor/gems/rdoc-2.4.3/test/test_rdoc_ri_default_display.rb +++ /dev/null @@ -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 diff --git a/vendor/gems/rdoc-2.4.3/test/test_rdoc_ri_driver.rb b/vendor/gems/rdoc-2.4.3/test/test_rdoc_ri_driver.rb deleted file mode 100644 index f16049205..000000000 --- a/vendor/gems/rdoc-2.4.3/test/test_rdoc_ri_driver.rb +++ /dev/null @@ -1,94 +0,0 @@ -require 'rubygems' -require 'minitest/unit' -require 'tmpdir' -require 'rdoc/ri/driver' - -class TestRDocRIDriver < MiniTest::Unit::TestCase - - def setup - @tmpdir = File.join Dir.tmpdir, "test_rdoc_ri_driver_#{$$}" - @home_ri = File.join @tmpdir, 'dot_ri' - @cache_dir = File.join @home_ri, 'cache' - @class_cache = File.join @cache_dir, 'classes' - - FileUtils.mkdir_p @tmpdir - FileUtils.mkdir_p @home_ri - FileUtils.mkdir_p @cache_dir - - @driver = RDoc::RI::Driver.new(RDoc::RI::Driver.process_args([])) - @driver.homepath = @home_ri - end - - def teardown - FileUtils.rm_rf @tmpdir - end - - def test_lookup_method - def @driver.load_cache_for(klassname) - { 'Foo#bar' => :found } - end - - assert @driver.lookup_method('Foo#bar', 'Foo') - end - - def test_lookup_method_class_method - def @driver.load_cache_for(klassname) - { 'Foo::Bar' => :found } - end - - assert @driver.lookup_method('Foo::Bar', 'Foo::Bar') - end - - def test_lookup_method_class_missing - def @driver.load_cache_for(klassname) end - - assert_nil @driver.lookup_method('Foo#bar', 'Foo') - end - - def test_lookup_method_dot_instance - def @driver.load_cache_for(klassname) - { 'Foo#bar' => :instance, 'Foo::bar' => :klass } - end - - assert_equal :instance, @driver.lookup_method('Foo.bar', 'Foo') - end - - def test_lookup_method_dot_class - def @driver.load_cache_for(klassname) - { 'Foo::bar' => :found } - end - - assert @driver.lookup_method('Foo.bar', 'Foo') - end - - def test_lookup_method_method_missing - def @driver.load_cache_for(klassname) {} end - - assert_nil @driver.lookup_method('Foo#bar', 'Foo') - end - - def test_parse_name - klass, meth = @driver.parse_name 'Foo::Bar' - - assert_equal 'Foo::Bar', klass, 'Foo::Bar class' - assert_equal nil, meth, 'Foo::Bar method' - - klass, meth = @driver.parse_name 'Foo#Bar' - - assert_equal 'Foo', klass, 'Foo#Bar class' - assert_equal 'Bar', meth, 'Foo#Bar method' - - klass, meth = @driver.parse_name 'Foo.Bar' - - assert_equal 'Foo', klass, 'Foo#Bar class' - assert_equal 'Bar', meth, 'Foo#Bar method' - - klass, meth = @driver.parse_name 'Foo::bar' - - assert_equal 'Foo', klass, 'Foo::bar class' - assert_equal 'bar', meth, 'Foo::bar method' - end - -end - -MiniTest::Unit.autorun diff --git a/vendor/gems/rdoc-2.4.3/test/test_rdoc_ri_formatter.rb b/vendor/gems/rdoc-2.4.3/test/test_rdoc_ri_formatter.rb deleted file mode 100644 index a70f9dcba..000000000 --- a/vendor/gems/rdoc-2.4.3/test/test_rdoc_ri_formatter.rb +++ /dev/null @@ -1,320 +0,0 @@ -require 'stringio' -require 'rubygems' -require 'minitest/unit' -require 'rdoc/ri/formatter' -require 'rdoc/markup/to_flow' - -class TestRDocRIFormatter < MiniTest::Unit::TestCase - - def setup - @output = StringIO.new - @width = 78 - @indent = ' ' - - @f = RDoc::RI::Formatter.new @output, @width, @indent - @markup = RDoc::Markup.new - @flow = RDoc::Markup::ToFlow.new - end - - def test_blankline - @f.blankline - - assert_equal "\n", @output.string - end - - def test_bold_print - @f.bold_print 'a b c' - - assert_equal 'a b c', @output.string - end - - def test_break_to_newline - @f.break_to_newline - - assert_equal '', @output.string - end - - def test_conv_html - assert_equal '> < " &', @f.conv_html('> < " &') - end - - def test_conv_markup - text = '<tt>a</tt> <code>b</code> <b>c</b> <em>d</em>' - - expected = '+a+ +b+ *c* _d_' - - assert_equal expected, @f.conv_markup(text) - end - - def test_display_flow - flow = [ - RDoc::Markup::Flow::H.new(1, 'heading'), - RDoc::Markup::Flow::P.new('paragraph'), - ] - - @f.display_flow flow - - assert_equal "\nHEADING\n=======\n\n paragraph\n\n", @output.string - end - - def test_display_flow_item_h - item = RDoc::Markup::Flow::H.new 1, 'heading' - - @f.display_flow_item item - - assert_equal "\nHEADING\n=======\n\n", @output.string - end - - def test_display_flow_item_li - item = RDoc::Markup::Flow::LI.new nil, 'paragraph' - - @f.display_flow_item item - - assert_equal " paragraph\n\n", @output.string - end - - def test_display_flow_item_list - item = RDoc::Markup::Flow::LIST.new :NUMBER - - @f.display_flow_item item - - assert_equal "", @output.string - end - - def test_display_flow_item_p - item = RDoc::Markup::Flow::P.new 'paragraph' - - @f.display_flow_item item - - assert_equal " paragraph\n\n", @output.string - end - - def test_display_flow_item_rule - item = RDoc::Markup::Flow::RULE.new 1 - - @f.display_flow_item item - - assert_equal "#{'-' * 78}\n", @output.string - end - - def test_display_flow_item_unknown - e = assert_raises RDoc::Error do - @f.display_flow_item Object.new - end - - assert_equal "Unknown flow element: Object", e.message - end - - def test_display_flow_item_verb - item = RDoc::Markup::Flow::VERB.new 'a b c' - - @f.display_flow_item item - - assert_equal " a b c\n\n", @output.string - end - - def test_display_heading_1 - @f.display_heading 'heading', 1, ' ' - - assert_equal "\nHEADING\n=======\n\n", @output.string - end - - def test_display_heading_2 - @f.display_heading 'heading', 2, ' ' - - assert_equal "\nheading\n-------\n\n", @output.string - end - - def test_display_heading_3 - @f.display_heading 'heading', 3, ' ' - - assert_equal " heading\n\n", @output.string - end - - def test_display_list - list = RDoc::Markup::Flow::LIST.new :NUMBER - list << RDoc::Markup::Flow::LI.new(nil, 'a b c') - list << RDoc::Markup::Flow::LI.new(nil, 'd e f') - - @f.display_list list - - assert_equal " 1. a b c\n\n 2. d e f\n\n", @output.string - end - - def test_display_list_bullet - list = RDoc::Markup::Flow::LIST.new :BULLET - list << RDoc::Markup::Flow::LI.new(nil, 'a b c') - - @f.display_list list - - assert_equal " * a b c\n\n", @output.string - end - - def test_display_list_labeled - list = RDoc::Markup::Flow::LIST.new :LABELED - list << RDoc::Markup::Flow::LI.new('label', 'a b c') - - @f.display_list list - - assert_equal " label a b c\n\n", @output.string - end - - def test_display_list_lower_alpha - list = RDoc::Markup::Flow::LIST.new :LOWERALPHA - list << RDoc::Markup::Flow::LI.new(nil, 'a b c') - - @f.display_list list - - assert_equal " a. a b c\n\n", @output.string - end - - def test_display_list_note - list = RDoc::Markup::Flow::LIST.new :NOTE - list << RDoc::Markup::Flow::LI.new('note:', 'a b c') - - @f.display_list list - - assert_equal " note: a b c\n\n", @output.string - end - - def test_display_list_number - list = RDoc::Markup::Flow::LIST.new :NUMBER - list << RDoc::Markup::Flow::LI.new(nil, 'a b c') - - @f.display_list list - - assert_equal " 1. a b c\n\n", @output.string - end - - def test_display_list_unknown - list = RDoc::Markup::Flow::LIST.new :UNKNOWN - list << RDoc::Markup::Flow::LI.new(nil, 'a b c') - - e = assert_raises ArgumentError do - @f.display_list list - end - - assert_equal 'unknown list type UNKNOWN', e.message - end - - def test_display_list_upper_alpha - list = RDoc::Markup::Flow::LIST.new :UPPERALPHA - list << RDoc::Markup::Flow::LI.new(nil, 'a b c') - - @f.display_list list - - assert_equal " A. a b c\n\n", @output.string - end - - def test_display_verbatim_flow_item - verbatim = RDoc::Markup::Flow::VERB.new "a b c\nd e f" - - @f.display_verbatim_flow_item verbatim - - assert_equal " a b c\n d e f\n\n", @output.string - end - - def test_display_verbatim_flow_item_bold - verbatim = RDoc::Markup::Flow::VERB.new "*a* b c" - - @f.display_verbatim_flow_item verbatim - - assert_equal " *a* b c\n\n", @output.string - end - - def test_draw_line - @f.draw_line - - expected = '-' * @width + "\n" - assert_equal expected, @output.string - end - - def test_draw_line_label - @f.draw_line 'label' - - expected = '-' * (@width - 6) + " label\n" - assert_equal expected, @output.string - end - - def test_draw_line_label_long - @f.draw_line 'a' * @width - - expected = '-' * @width + "\n" + ('a' * @width) + "\n" - assert_equal expected, @output.string - end - - def test_raw_print_line - @f.raw_print_line 'a b c' - - assert_equal "a b c", @output.string - end - - def test_strip_attributes_b - text = @f.strip_attributes 'hello <b>world</b>' - - expected = 'hello world' - - assert_equal expected, text - end - - def test_strip_attributes_code - text = @f.strip_attributes 'hello <code>world</code>' - - expected = 'hello world' - - assert_equal expected, text - end - - def test_strip_attributes_em - text = @f.strip_attributes 'hello <em>world</em>' - - expected = 'hello world' - - assert_equal expected, text - end - - def test_strip_attributes_i - text = @f.strip_attributes 'hello <i>world</i>' - - expected = 'hello world' - - assert_equal expected, text - end - - def test_strip_attributes_tt - text = @f.strip_attributes 'hello <tt>world</tt>' - - expected = 'hello world' - - assert_equal expected, text - 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 diff --git a/vendor/gems/rdoc-2.4.3/test/test_rdoc_ri_html_formatter.rb b/vendor/gems/rdoc-2.4.3/test/test_rdoc_ri_html_formatter.rb deleted file mode 100644 index 2206cd631..000000000 --- a/vendor/gems/rdoc-2.4.3/test/test_rdoc_ri_html_formatter.rb +++ /dev/null @@ -1,141 +0,0 @@ -require 'stringio' -require 'rubygems' -require 'minitest/unit' -require 'rdoc/ri/formatter' -require 'rdoc/markup/fragments' -require 'rdoc/markup/to_flow' - -class TestRDocRIHtmlFormatter < MiniTest::Unit::TestCase - - def setup - @output = StringIO.new - @width = 78 - @indent = ' ' - - @f = RDoc::RI::HtmlFormatter.new @output, @width, @indent - @markup = RDoc::Markup.new - @flow = RDoc::Markup::ToFlow.new - @af = RDoc::RI::AttributeFormatter - end - - def test_blankline - @f.blankline - - assert_equal "<p />\n", @output.string - end - - def test_bold_print - @f.bold_print 'text' - - assert_equal '<b>text</b>', @output.string - end - - def test_break_to_newline - @f.break_to_newline - - assert_equal "<br />\n", @output.string - end - - def test_display_heading - @f.display_heading 'text', 1, ' ' - - assert_equal "<h1>text</h1>\n", @output.string - end - - def test_display_heading_level_4 - @f.display_heading 'text', 4, ' ' - - assert_equal "<h4>text</h4>\n", @output.string - end - - def test_display_heading_level_5 - @f.display_heading 'text', 5, ' ' - - assert_equal "<h4>text</h4>\n", @output.string - end - - def test_display_list_bullet - list = RDoc::Markup::Flow::LIST.new :BULLET - list << RDoc::Markup::Flow::LI.new(nil, 'a b c') - list << RDoc::Markup::Flow::LI.new(nil, 'd e f') - - @f.display_list list - - expected = <<-EOF.strip -<ul><li>a b c<p /> -</li><li>d e f<p /> -</li></ul> - EOF - - assert_equal expected, @output.string - end - - def test_display_list_number - list = RDoc::Markup::Flow::LIST.new :NUMBER - list << RDoc::Markup::Flow::LI.new(nil, 'a b c') - list << RDoc::Markup::Flow::LI.new(nil, 'd e f') - - @f.display_list list - - expected = <<-EOF.strip -<ol><li>a b c<p /> -</li><li>d e f<p /> -</li></ol> - EOF - - assert_equal expected, @output.string - end - - def test_display_list_labeled - list = RDoc::Markup::Flow::LIST.new :LABELED - list << RDoc::Markup::Flow::LI.new('label', 'a b c') - list << RDoc::Markup::Flow::LI.new('label 2', 'd e f') - - @f.display_list list - - expected = <<-EOF.strip -<dl><dt><b>label</b></dt><dd>a b c<p /> -</dd><dt><b>label 2</b></dt><dd>d e f<p /> -</dd></dl> - EOF - - assert_equal expected, @output.string - end - - def test_display_list_note - list = RDoc::Markup::Flow::LIST.new :NOTE - list << RDoc::Markup::Flow::LI.new('note:', 'a b c') - list << RDoc::Markup::Flow::LI.new('note 2:', 'd e f') - - @f.display_list list - - expected = <<-EOF.strip -<table><tr valign="top"><td>note:</td><td>a b c<p /> -</td></tr><tr valign="top"><td>note 2:</td><td>d e f<p /> -</td></tr></table> - EOF - - assert_equal expected, @output.string - end - - def test_display_verbatim_flow_item - verbatim = RDoc::Markup::Flow::VERB.new '*a* > b > c' - @f.display_verbatim_flow_item verbatim - - assert_equal "<pre>*a* > b &gt; c\n</pre>\n", @output.string - end - - def test_draw_line - @f.draw_line - - assert_equal "<hr />\n", @output.string - end - - def test_draw_line_label - @f.draw_line 'label' - - assert_equal "<b>label</b><hr />\n", @output.string - end - -end - diff --git a/vendor/gems/rdoc-2.4.3/test/test_rdoc_ri_overstrike_formatter.rb b/vendor/gems/rdoc-2.4.3/test/test_rdoc_ri_overstrike_formatter.rb deleted file mode 100644 index 38b95414d..000000000 --- a/vendor/gems/rdoc-2.4.3/test/test_rdoc_ri_overstrike_formatter.rb +++ /dev/null @@ -1,71 +0,0 @@ -require 'stringio' -require 'rubygems' -require 'minitest/unit' -require 'rdoc/ri/formatter' -require 'rdoc/markup/fragments' -require 'rdoc/markup/to_flow' - -class TestRDocRIOverstrikeFormatter < MiniTest::Unit::TestCase - - def setup - @output = StringIO.new - @width = 78 - @indent = ' ' - - @f = RDoc::RI::OverstrikeFormatter.new @output, @width, @indent - @markup = RDoc::Markup.new - @flow = RDoc::Markup::ToFlow.new - - @af = RDoc::RI::AttributeFormatter - end - - def test_display_verbatim_flow_item_bold - verbatim = RDoc::Markup::Flow::VERB.new "*a* b c" - - @f.display_verbatim_flow_item verbatim - - assert_equal " *a* b c\n\n", @output.string - end - - def test_write_attribute_text_bold - line = [RDoc::RI::AttributeFormatter::AttrChar.new('b', @af::BOLD)] - - @f.write_attribute_text ' ', line - - assert_equal " b\bb\n", @output.string - end - - def test_write_attribute_text_bold_italic - attr = @af::BOLD | @af::ITALIC - line = [RDoc::RI::AttributeFormatter::AttrChar.new('d', attr)] - - @f.write_attribute_text ' ', line - - assert_equal " _\bd\bd\n", @output.string - end - - def test_write_attribute_text_code - line = [RDoc::RI::AttributeFormatter::AttrChar.new('c', @af::CODE)] - - @f.write_attribute_text ' ', line - - assert_equal " _\bc\n", @output.string - end - - def test_write_attribute_text_italic - line = [RDoc::RI::AttributeFormatter::AttrChar.new('a', @af::ITALIC)] - - @f.write_attribute_text ' ', line - - assert_equal " _\ba\n", @output.string - end - - def test_bold_print - @f.bold_print 'a b c' - - assert_equal "a\ba \b b\bb \b c\bc", @output.string - end - -end - -MiniTest::Unit.autorun diff --git a/vendor/gems/rdoc-2.4.3/test/test_rdoc_task.rb b/vendor/gems/rdoc-2.4.3/test/test_rdoc_task.rb deleted file mode 100644 index dd3114fb5..000000000 --- a/vendor/gems/rdoc-2.4.3/test/test_rdoc_task.rb +++ /dev/null @@ -1,64 +0,0 @@ -require 'rubygems' -require 'minitest/autorun' -require 'rdoc/task' - -class TestRDocTask < MiniTest::Unit::TestCase - - def setup - Rake::Task.clear - 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_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 - rd = 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 - diff --git a/vendor/gems/rdoc-2.4.3/test/test_rdoc_top_level.rb b/vendor/gems/rdoc-2.4.3/test/test_rdoc_top_level.rb deleted file mode 100644 index 3287eacfa..000000000 --- a/vendor/gems/rdoc-2.4.3/test/test_rdoc_top_level.rb +++ /dev/null @@ -1,85 +0,0 @@ -require 'rubygems' -require 'minitest/unit' -require 'test/xref_test_case' - -class TestRDocTopLevel < XrefTestCase - - def setup - super - - @top_level = RDoc::TopLevel.new 'path/top_level.rb' - end - - def test_class_all_classes_and_modules - assert_equal %w[C1 C2 C2::C3 C2::C3::H1 C3 C3::H1 C3::H2 C4 C4::C4 M1], - RDoc::TopLevel.all_classes_and_modules.map { |m| m.full_name }.sort - end - - def test_class_classes - assert_equal %w[C1 C2 C2::C3 C2::C3::H1 C3 C3::H1 C3::H2 C4 C4::C4], - RDoc::TopLevel.classes.map { |m| m.full_name }.sort - end - - def test_class_files - assert_equal %w[path/top_level.rb xref_data.rb], - RDoc::TopLevel.files.map { |m| m.full_name }.sort - end - - def test_class_find_class_named - assert_equal @c1, RDoc::TopLevel.find_class_named('C1') - end - - def test_class_find_file_named - assert_equal @xref_data, RDoc::TopLevel.find_file_named(@file_name) - end - - def test_class_find_module_named - assert_equal @m1, RDoc::TopLevel.find_module_named('M1') - end - - def test_class_modules - assert_equal %w[M1], - RDoc::TopLevel.modules.map { |m| m.full_name }.sort - end - - def test_class_reset - RDoc::TopLevel.reset - - assert_empty RDoc::TopLevel.classes - assert_empty RDoc::TopLevel.modules - assert_empty RDoc::TopLevel.files - end - - def test_base_name - assert_equal 'top_level.rb', @top_level.base_name - end - - def test_find_class_or_module_named - assert_equal @c1, @xref_data.find_class_or_module_named('C1') - assert_equal @c4, @xref_data.find_class_or_module_named('C4') - end - - def test_full_name - assert_equal 'path/top_level.rb', @top_level.full_name - end - - def test_http_url - assert_equal 'prefix/path/top_level_rb.html', @top_level.http_url('prefix') - end - - def test_last_modified - assert_equal 'Unknown', @top_level.last_modified - - stat = Object.new - def stat.mtime() 0 end - @top_level.file_stat = stat - - assert_equal '0', @top_level.last_modified - end - - def test_name - assert_equal 'top_level.rb', @top_level.name - end - -end - diff --git a/vendor/gems/rdoc-2.4.3/test/xref_data.rb b/vendor/gems/rdoc-2.4.3/test/xref_data.rb deleted file mode 100644 index 5d7e42bc2..000000000 --- a/vendor/gems/rdoc-2.4.3/test/xref_data.rb +++ /dev/null @@ -1,46 +0,0 @@ -XREF_DATA = <<-XREF_DATA -class C1 - - attr :attr - attr_reader :attr_reader - attr_writer :attr_writer - attr_accessor :attr_accessor - - CONST = :const - - def self.m - end - - def m - end -end - -class C2 - class C3 - def m - end - - class H1 - def m? - end - end - end -end - -class C3 - class H1 - end - - class H2 - end -end - -class C4 - class C4 - end -end - -module M1 -end -XREF_DATA - diff --git a/vendor/gems/rdoc-2.4.3/test/xref_test_case.rb b/vendor/gems/rdoc-2.4.3/test/xref_test_case.rb deleted file mode 100644 index 9c8b4748d..000000000 --- a/vendor/gems/rdoc-2.4.3/test/xref_test_case.rb +++ /dev/null @@ -1,48 +0,0 @@ -require 'rubygems' -require 'minitest/unit' -require 'rdoc/stats' -require 'rdoc/options' -require 'rdoc/code_objects' -require 'rdoc/parser/ruby' -require 'test/xref_data' - -class XrefTestCase < MiniTest::Unit::TestCase - - def setup - RDoc::TopLevel.reset - RDoc::AnyMethod.reset - - @file_name = 'xref_data.rb' - @xref_data = RDoc::TopLevel.new @file_name - - @options = RDoc::Options.new - @options.quiet = true - - stats = RDoc::Stats.new 0 - - parser = RDoc::Parser::Ruby.new @xref_data, @file_name, XREF_DATA, @options, - stats - @top_levels = [] - @top_levels.push parser.scan - - generator = Object.new - def generator.class_dir() nil end - def generator.file_dir() nil end - rdoc = RDoc::RDoc.new - RDoc::RDoc.current = rdoc - rdoc.generator = generator - - @c1 = @xref_data.find_module_named 'C1' - @c2 = @xref_data.find_module_named 'C2' - @c2_c3 = @xref_data.find_module_named 'C2::C3' - @c3 = @xref_data.find_module_named 'C3' - @c4 = @xref_data.find_module_named 'C4' - @c4_c4 = @xref_data.find_module_named 'C4::C4' - - @m1 = @xref_data.find_module_named 'M1' - end - -end - -MiniTest::Unit.autorun - |