horseman 0.0.1 → 0.0.2

data/vendor/ruby/1.9.1/gems/rdoc-3.11/test/test_rdoc_markup_attribute_manager.rb

@@ -0,0 +1,237 @@
+require 'rdoc/test_case'
+
+class TestRDocMarkupAttributeManager < RDoc::TestCase
+
+  def setup
+    super
+
+    @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 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 @am.word_pair_map.include?(/(%)(\S+)(&)/)
+    assert @am.protectable.include?('%')
+    assert !@am.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 @am.matching_word_pairs.include?('^')
+    assert @am.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::CrossReference::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
+

data/vendor/ruby/1.9.1/gems/rdoc-3.11/test/test_rdoc_markup_document.rb

@@ -0,0 +1,180 @@
+require 'rdoc/test_case'
+
+class TestRDocMarkupDocument < RDoc::TestCase
+
+  def setup
+    super
+
+    @d = @RM::Document.new
+  end
+
+  def mu_pp obj
+    s = ''
+    s = PP.pp obj, s
+    s.force_encoding Encoding.default_external if defined? Encoding
+    s.chomp
+  end
+
+  def test_append
+    @d << @RM::Paragraph.new('hi')
+
+    expected = @RM::Document.new @RM::Paragraph.new('hi')
+
+    assert_equal expected, @d
+  end
+
+  def test_append_document
+    @d << @RM::Document.new
+
+    assert_empty @d
+
+    @d << @RM::Document.new(@RM::Paragraph.new('hi'))
+
+    expected = @RM::Document.new @RM::Paragraph.new('hi'), @RM::BlankLine.new
+
+    assert_equal expected, @d
+  end
+
+  def test_append_string
+    @d << ''
+
+    assert_empty @d
+
+    assert_raises ArgumentError do
+      @d << 'hi'
+    end
+  end
+
+  def test_empty_eh
+    assert_empty @d
+
+    @d << @RM::BlankLine.new
+
+    refute_empty @d
+  end
+
+  def test_empty_eh_document
+    d = @RM::Document.new @d
+
+    assert_empty d
+  end
+
+  def test_equals2
+    d2 = @RM::Document.new
+
+    assert_equal @d, d2
+
+    d2 << @RM::BlankLine.new
+
+    refute_equal @d, d2
+  end
+
+  def test_equals2_file
+    d2 = @RM::Document.new
+    d2.file = 'file.rb'
+
+    refute_equal @d, d2
+
+    @d.file = 'file.rb'
+
+    assert_equal @d, d2
+  end
+
+  def test_file_equals
+    @d.file = 'file.rb'
+
+    assert_equal 'file.rb', @d.file
+  end
+
+  def test_file_equals_top_level
+    @d.file = RDoc::TopLevel.new 'file.rb'
+
+    assert_equal 'file.rb', @d.file
+  end
+
+  def test_lt2
+    @d << @RM::BlankLine.new
+
+    refute_empty @d
+  end
+
+  def test_merge
+    original = @RM::Document.new @RM::Paragraph.new 'original'
+    original.file = 'file.rb'
+    root = @RM::Document.new original
+
+    replace = @RM::Document.new @RM::Paragraph.new 'replace'
+    replace.file = 'file.rb'
+
+    other = @RM::Document.new replace
+
+    result = root.merge other
+
+    inner = @RM::Document.new @RM::Paragraph.new 'replace'
+    inner.file = 'file.rb'
+    expected = @RM::Document.new inner
+
+    assert_equal expected, result
+  end
+
+  def test_merge_add
+    original = @RM::Document.new @RM::Paragraph.new 'original'
+    original.file = 'file.rb'
+    root = @RM::Document.new original
+
+    addition = @RM::Document.new @RM::Paragraph.new 'addition'
+    addition.file = 'other.rb'
+
+    other = @RM::Document.new addition
+
+    result = root.merge other
+
+    expected = @RM::Document.new original, addition
+
+    assert_equal expected, result
+  end
+
+  def test_merge_empty
+    original = @RM::Document.new
+    root = @RM::Document.new original
+
+    replace = @RM::Document.new @RM::Paragraph.new 'replace'
+    replace.file = 'file.rb'
+
+    other = @RM::Document.new replace
+
+    result = root.merge other
+
+    inner = @RM::Document.new @RM::Paragraph.new 'replace'
+    inner.file = 'file.rb'
+    expected = @RM::Document.new inner
+
+    assert_equal expected, result
+  end
+
+  def test_push
+    @d.push @RM::BlankLine.new, @RM::BlankLine.new
+
+    refute_empty @d
+  end
+
+  def test_table_of_contents
+    doc = @RM::Document.new(
+      @RM::Heading.new(1, 'A'),
+      @RM::Paragraph.new('B'),
+      @RM::Heading.new(2, 'C'),
+      @RM::Paragraph.new('D'),
+      @RM::Heading.new(1, 'E'),
+      @RM::Paragraph.new('F'))
+
+    expected = [
+      @RM::Heading.new(1, 'A'),
+      @RM::Heading.new(2, 'C'),
+      @RM::Heading.new(1, 'E'),
+    ]
+
+    assert_equal expected, doc.table_of_contents
+  end
+
+end
+

data/vendor/ruby/1.9.1/gems/rdoc-3.11/test/test_rdoc_markup_formatter.rb

@@ -0,0 +1,55 @@
+require 'rdoc/test_case'
+
+class TestRDocMarkupFormatter < RDoc::TestCase
+
+  class ToTest < RDoc::Markup::Formatter
+
+    def initialize markup
+      super
+
+      add_tag :TT, '<code>', '</code>'
+    end
+
+    def accept_paragraph paragraph
+      @res << attributes(paragraph.text)
+    end
+
+    def attributes text
+      convert_flow @am.flow text.dup
+    end
+
+    def handle_special_CAPS special
+      "handled #{special.text}"
+    end
+
+    def start_accepting
+      @res = ""
+    end
+
+    def end_accepting
+      @res
+    end
+
+  end
+
+  def setup
+    super
+
+    @markup = @RM.new
+    @markup.add_special(/[A-Z]+/, :CAPS)
+
+    @to = ToTest.new @markup
+
+    @caps    = @RM::Attribute.bitmap_for :CAPS
+    @special = @RM::Attribute.bitmap_for :_SPECIAL_
+    @tt      = @RM::Attribute.bitmap_for :TT
+  end
+
+  def test_convert_tt_special
+    converted = @to.convert '<code>AAA</code>'
+
+    assert_equal '<code>AAA</code>', converted
+  end
+
+end
+

data/vendor/ruby/1.9.1/gems/rdoc-3.11/test/test_rdoc_markup_heading.rb

@@ -0,0 +1,20 @@
+require 'rdoc/test_case'
+
+class TestRDocMarkupHeading < RDoc::TestCase
+
+  def setup
+    super
+
+    @h = RDoc::Markup::Heading.new 1, 'Hello *Friend*!'
+  end
+
+  def test_aref
+    assert_equal 'label-Hello+Friend%21', @h.aref
+  end
+
+  def test_plain_html
+    assert_equal 'Hello <strong>Friend</strong>!', @h.plain_html
+  end
+
+end
+

data/vendor/ruby/1.9.1/gems/rdoc-3.11/test/test_rdoc_markup_include.rb

@@ -0,0 +1,19 @@
+require 'rdoc/test_case'
+
+class TestRDocMarkupInclude < RDoc::TestCase
+
+  def setup
+    super
+
+    @include = @RM::Include.new 'file', [Dir.tmpdir]
+  end
+
+  def test_equals2
+    assert_equal @include, @RM::Include.new('file', [Dir.tmpdir])
+    refute_equal @include, @RM::Include.new('file', %w[.])
+    refute_equal @include, @RM::Include.new('other', [Dir.tmpdir])
+    refute_equal @include, Object.new
+  end
+
+end
+

data/vendor/ruby/1.9.1/gems/rdoc-3.11/test/test_rdoc_markup_indented_paragraph.rb

@@ -0,0 +1,39 @@
+require 'rdoc/test_case'
+
+class TestRDocMarkupIndentedParagraph < RDoc::TestCase
+
+  def setup
+    super
+
+    @IP = RDoc::Markup::IndentedParagraph
+  end
+
+  def test_initialize
+    ip = @IP.new 2, 'a', 'b'
+
+    assert_equal 2, ip.indent
+    assert_equal %w[a b], ip.parts
+  end
+
+  def test_accept
+    visitor = Object.new
+    def visitor.accept_indented_paragraph(obj) @obj = obj end
+    def visitor.obj() @obj end
+
+    paragraph = @IP.new 0
+
+    paragraph.accept visitor
+
+    assert_equal paragraph, visitor.obj
+  end
+
+  def test_equals2
+    one = @IP.new 1
+    two = @IP.new 2
+
+    assert_equal one, one
+    refute_equal one, two
+  end
+
+end
+

data/vendor/ruby/1.9.1/gems/rdoc-3.11/test/test_rdoc_markup_paragraph.rb

@@ -0,0 +1,18 @@
+require 'rdoc/test_case'
+
+class TestRDocMarkupParagraph < RDoc::TestCase
+
+  def test_accept
+    visitor = Object.new
+    def visitor.accept_paragraph(obj) @obj = obj end
+    def visitor.obj() @obj end
+
+    paragraph = RDoc::Markup::Paragraph.new
+
+    paragraph.accept visitor
+
+    assert_equal paragraph, visitor.obj
+  end
+
+end
+