rdoc 3.12.2 → 4.0.0.preview2

data/lib/rdoc/markup/attr_changer.rb

@@ -11,14 +11,11 @@ end
 class RDoc::Markup::AttrChanger
 
   def to_s # :nodoc:
-    "Attr: +#{RDoc::Markup::Attribute.as_string turn_on}/-#{RDoc::Markup::Attribute.as_string turn_off}"
+    "Attr: +#{turn_on}/-#{turn_off}"
   end
 
   def inspect # :nodoc:
-    "+%s/-%s" % [
-      RDoc::Markup::Attribute.as_string(turn_on),
-      RDoc::Markup::Attribute.as_string(turn_off),
-    ]
+    '+%d/-%d' % [turn_on, turn_off]
   end
 
 end

data/lib/rdoc/markup/attribute_manager.rb

@@ -22,6 +22,11 @@ class RDoc::Markup::AttributeManager
 
   PROTECT_ATTR = A_PROTECT.chr # :nodoc:
 
+  ##
+  # The attributes enabled for this markup object.
+
+  attr_reader :attributes
+
   ##
   # This maps delimiters that occur around words (such as *bold* or +tt+)
   # where the start and end delimiters and the same. This lets us optimize
@@ -60,8 +65,9 @@ class RDoc::Markup::AttributeManager
     @html_tags = {}
     @matching_word_pairs = {}
     @protectable = %w[<]
-    @special = {}
+    @special = []
     @word_pair_map = {}
+    @attributes = RDoc::Markup::Attributes.new
 
     add_word_pair "*", "*", :BOLD
     add_word_pair "_", "_", :EM
@@ -96,11 +102,11 @@ class RDoc::Markup::AttributeManager
   def changed_attribute_by_name current_set, new_set
     current = new = 0
     current_set.each do |name|
-      current |= RDoc::Markup::Attribute.bitmap_for(name)
+      current |= @attributes.bitmap_for(name)
     end
 
     new_set.each do |name|
-      new |= RDoc::Markup::Attribute.bitmap_for(name)
+      new |= @attributes.bitmap_for(name)
     end
 
     change_attribute(current, new)
@@ -161,12 +167,15 @@ class RDoc::Markup::AttributeManager
   ##
   # Converts special sequences to RDoc attributes
 
-  def convert_specials(str, attrs)
+  def convert_specials str, attrs
     unless @special.empty?
-      @special.each do |regexp, attr|
+      @special.each do |regexp, attribute|
         str.scan(regexp) do
-          attrs.set_attrs($`.length, $&.length,
-                          attr | RDoc::Markup::Attribute::SPECIAL)
+          capture = $~.size == 1 ? 0 : 1
+
+          s, e = $~.offset capture
+
+          attrs.set_attrs s, e - s, attribute | @attributes.special
         end
       end
     end
@@ -200,7 +209,7 @@ class RDoc::Markup::AttributeManager
     raise ArgumentError, "Word flags may not start with '<'" if
       start[0,1] == '<'
 
-    bitmap = RDoc::Markup::Attribute.bitmap_for name
+    bitmap = @attributes.bitmap_for name
 
     if start == stop then
       @matching_word_pairs[start] = bitmap
@@ -220,7 +229,7 @@ class RDoc::Markup::AttributeManager
   #   am.add_html 'em', :EM
 
   def add_html(tag, name)
-    @html_tags[tag.downcase] = RDoc::Markup::Attribute.bitmap_for name
+    @html_tags[tag.downcase] = @attributes.bitmap_for name
   end
 
   ##
@@ -229,14 +238,14 @@ class RDoc::Markup::AttributeManager
   #
   #   @am.add_special(/((https?:)\S+\w)/, :HYPERLINK)
 
-  def add_special(pattern, name)
-    @special[pattern] = RDoc::Markup::Attribute.bitmap_for name
+  def add_special pattern, name
+    @special << [pattern, @attributes.bitmap_for(name)]
   end
 
   ##
   # Processes +str+ converting attributes, HTML and specials
 
-  def flow(str)
+  def flow str
     @str = str
 
     mask_protected_sequences
@@ -303,9 +312,9 @@ class RDoc::Markup::AttributeManager
         res << change_attribute(current_attr, new_attr)
         current_attr = new_attr
 
-        if (current_attr & RDoc::Markup::Attribute::SPECIAL) != 0 then
+        if (current_attr & @attributes.special) != 0 then
           i += 1 while
-            i < str_len and (@attrs[i] & RDoc::Markup::Attribute::SPECIAL) != 0
+            i < str_len and (@attrs[i] & @attributes.special) != 0
 
           res << RDoc::Markup::Special.new(current_attr,
                                            copy_string(start_pos, i))

data/lib/rdoc/markup/attributes.rb

@@ -0,0 +1,70 @@
+##
+# We manage a set of attributes.  Each attribute has a symbol name and a bit
+# value.
+
+class RDoc::Markup::Attributes
+
+  ##
+  # The special attribute type.  See RDoc::Markup#add_special
+
+  attr_reader :special
+
+  ##
+  # Creates a new attributes set.
+
+  def initialize
+    @special = 1
+
+    @name_to_bitmap = [
+      [:_SPECIAL_, @special],
+    ]
+
+    @next_bitmap = @special << 1
+  end
+
+  ##
+  # Returns a unique bit for +name+
+
+  def bitmap_for name
+    bitmap = @name_to_bitmap.assoc name
+
+    unless bitmap then
+      bitmap = @next_bitmap
+      @next_bitmap <<= 1
+      @name_to_bitmap << [name, bitmap]
+    else
+      bitmap = bitmap.last
+    end
+
+    bitmap
+  end
+
+  ##
+  # Returns a string representation of +bitmap+
+
+  def as_string bitmap
+    return 'none' if bitmap.zero?
+    res = []
+
+    @name_to_bitmap.each do |name, bit|
+      res << name if (bitmap & bit) != 0
+    end
+
+    res.join ','
+  end
+
+  ##
+  # yields each attribute name in +bitmap+
+
+  def each_name_of bitmap
+    return enum_for __method__, bitmap unless block_given?
+
+    @name_to_bitmap.each do |name, bit|
+      next if bit == @special
+
+      yield name.to_s if (bitmap & bit) != 0
+    end
+  end
+
+end
+

data/lib/rdoc/markup/block_quote.rb

@@ -0,0 +1,14 @@
+##
+# A quoted section which contains markup items.
+
+class RDoc::Markup::BlockQuote < RDoc::Markup::Raw
+
+  ##
+  # Calls #accept_block_quote on +visitor+
+
+  def accept visitor
+    visitor.accept_block_quote self
+  end
+
+end
+

data/lib/rdoc/markup/document.rb

@@ -3,6 +3,8 @@
 
 class RDoc::Markup::Document
 
+  include Enumerable
+
   ##
   # The file this document was created from.  See also
   # RDoc::ClassModule#add_comment
@@ -19,7 +21,7 @@ class RDoc::Markup::Document
 
   def initialize *parts
     @parts = []
-    @parts.push(*parts)
+    @parts.concat parts
 
     @file = nil
   end
@@ -31,7 +33,7 @@ class RDoc::Markup::Document
     case part
     when RDoc::Markup::Document then
       unless part.empty? then
-        parts.push(*part.parts)
+        parts.concat part.parts
         parts << RDoc::Markup::BlankLine.new
       end
     when String then
@@ -67,6 +69,20 @@ class RDoc::Markup::Document
     visitor.end_accepting
   end
 
+  ##
+  # Concatenates the given +parts+ onto the document
+
+  def concat parts
+    self.parts.concat parts
+  end
+
+  ##
+  # Enumerator for the parts of this document
+
+  def each &block
+    @parts.each(&block)
+  end
+
   ##
   # Does this document have no parts?
 
@@ -80,7 +96,7 @@ class RDoc::Markup::Document
   def file= location
     @file = case location
             when RDoc::TopLevel then
-              location.absolute_name
+              location.relative_name
             else
               location
             end
@@ -132,7 +148,7 @@ class RDoc::Markup::Document
   # Appends +parts+ to the document
 
   def push *parts
-    self.parts.push(*parts)
+    self.parts.concat parts
   end
 
   ##

data/lib/rdoc/markup/formatter.rb

@@ -20,14 +20,21 @@ class RDoc::Markup::Formatter
   ##
   # Creates a new Formatter
 
-  def initialize markup = nil
+  def initialize options, markup = nil
+    @options = options
+
     @markup = markup || RDoc::Markup.new
     @am     = @markup.attribute_manager
+    @am.add_special(/<br>/, :HARD_BREAK)
+
+    @attributes = @am.attributes
 
     @attr_tags = []
 
     @in_tt = 0
-    @tt_bit = RDoc::Markup::Attribute.bitmap_for :TT
+    @tt_bit = @attributes.bitmap_for :TT
+
+    @hard_break = ''
   end
 
   ##
@@ -44,7 +51,7 @@ class RDoc::Markup::Formatter
   # tags for flexibility
 
   def add_tag(name, start, stop)
-    attr = RDoc::Markup::Attribute.bitmap_for name
+    attr = @attributes.bitmap_for name
     @attr_tags << InlineTag.new(attr, start, stop)
   end
 
@@ -93,7 +100,7 @@ class RDoc::Markup::Formatter
 
     handled = false
 
-    RDoc::Markup::Attribute.each_name_of special.type do |name|
+    @attributes.each_name_of special.type do |name|
       method_name = "handle_special_#{name}"
 
       if respond_to? method_name then
@@ -102,7 +109,11 @@ class RDoc::Markup::Formatter
       end
     end
 
-    raise "Unhandled special: #{special}" unless handled
+    unless handled then
+      special_name = @attributes.as_string special.type
+
+      raise RDoc::Error, "Unhandled special #{special_name}: #{special}"
+    end
 
     special.text
   end
@@ -122,7 +133,7 @@ class RDoc::Markup::Formatter
   #
   #   alias accept_raw ignore
 
-  def ignore node
+  def ignore *node
   end
 
   ##

data/lib/rdoc/markup/formatter_test_case.rb

@@ -34,7 +34,7 @@ require 'minitest/unit'
 #
 #  end
 
-class RDoc::Markup::FormatterTestCase < MiniTest::Unit::TestCase
+class RDoc::Markup::FormatterTestCase < RDoc::TestCase
 
   ##
   # Call #setup when inheriting from this test case.
@@ -53,7 +53,8 @@ class RDoc::Markup::FormatterTestCase < MiniTest::Unit::TestCase
   def setup
     super
 
-    @RM = RDoc::Markup
+    @options = RDoc::Options.new
+
     @m = @RM.new
 
     @bullet_list = @RM::List.new(:BULLET,
@@ -85,7 +86,7 @@ class RDoc::Markup::FormatterTestCase < MiniTest::Unit::TestCase
   # Call to add the visitor tests to your test case
 
   def self.add_visitor_tests
-    self.class_eval do
+    class_eval do
 
       ##
       # Calls start_accepting which needs to verify startup state
@@ -118,6 +119,16 @@ class RDoc::Markup::FormatterTestCase < MiniTest::Unit::TestCase
         accept_blank_line
       end
 
+      ##
+      # Calls accept_block_quote
+
+      def test_accept_block_quote
+        @to.start_accepting
+
+        @to.accept_block_quote block para 'quote'
+
+        accept_block_quote
+      end
       ##
       # Test case that calls <tt>@to.accept_document</tt>
 
@@ -232,6 +243,29 @@ class RDoc::Markup::FormatterTestCase < MiniTest::Unit::TestCase
         accept_paragraph_b
       end
 
+      ##
+      # Calls accept_paragraph_br with a RDoc::Markup::Paragraph containing
+      # a \<br>
+
+      def test_accept_paragraph_br
+        @to.start_accepting
+
+        @to.accept_paragraph para 'one<br>two'
+
+        accept_paragraph_br
+      end
+
+      ##
+      # Calls accept_paragraph with a Paragraph containing a hard break
+
+      def test_accept_paragraph_break
+        @to.start_accepting
+
+        @to.accept_paragraph para('hello', hard_break, 'world')
+
+        accept_paragraph_break
+      end
+
       ##
       # Calls accept_paragraph_i with a RDoc::Markup::Paragraph containing
       # emphasized words
@@ -373,9 +407,9 @@ class RDoc::Markup::FormatterTestCase < MiniTest::Unit::TestCase
       # Calls accept_list_item_start_note_2
 
       def test_accept_list_item_start_note_2
-        list = @RM::List.new(:NOTE,
-                 @RM::ListItem.new('<tt>teletype</tt>',
-                   @RM::Paragraph.new('teletype description')))
+        list = list(:NOTE,
+                 item('<tt>teletype</tt>',
+                   para('teletype description')))
 
         @to.start_accepting
 
@@ -386,6 +420,41 @@ class RDoc::Markup::FormatterTestCase < MiniTest::Unit::TestCase
         accept_list_item_start_note_2
       end
 
+      ##
+      # Calls accept_list_item_start_note_multi_description
+
+      def test_accept_list_item_start_note_multi_description
+        list = list(:NOTE,
+                 item(%w[label],
+                   para('description one')),
+                 item(nil, para('description two')))
+
+        @to.start_accepting
+
+        list.accept @to
+
+        @to.end_accepting
+
+        accept_list_item_start_note_multi_description
+      end
+
+      ##
+      # Calls accept_list_item_start_note_multi_label
+
+      def test_accept_list_item_start_note_multi_label
+        list = list(:NOTE,
+                 item(%w[one two],
+                   para('two headers')))
+
+        @to.start_accepting
+
+        list.accept @to
+
+        @to.end_accepting
+
+        accept_list_item_start_note_multi_label
+      end
+
       ##
       # Calls accept_list_item_start_number
 
@@ -634,7 +703,7 @@ class RDoc::Markup::FormatterTestCase < MiniTest::Unit::TestCase
       end
 
       ##
-      # Calls accept_list_end_ulpha
+      # Calls accept_list_end_ualpha
 
       def test_accept_list_end_ualpha
         @to.start_accepting
@@ -669,28 +738,28 @@ class RDoc::Markup::FormatterTestCase < MiniTest::Unit::TestCase
       # Calls list_verbatim with a list containing a verbatim block
 
       def test_list_verbatim # HACK overblown
-        doc = @RM::Document.new(
-                @RM::List.new(:BULLET,
-                  @RM::ListItem.new(nil,
-                    @RM::Paragraph.new('list', 'stuff'),
-                    @RM::BlankLine.new,
-                    @RM::Verbatim.new("* list\n",
-                                      "  with\n",
-                                      "\n",
-                                      "  second\n",
-                                      "\n",
-                                      "  1. indented\n",
-                                      "  2. numbered\n",
-                                      "\n",
-                                      "  third\n",
-                                      "\n",
-                                      "* second\n"))))
+        doc =
+          doc(
+            list(:BULLET,
+              item(nil,
+                para('list stuff'),
+                blank_line,
+                verb("* list\n",
+                     "  with\n",
+                     "\n",
+                     "  second\n",
+                     "\n",
+                     "  1. indented\n",
+                     "  2. numbered\n",
+                     "\n",
+                     "  third\n",
+                     "\n",
+                     "* second\n"))))
 
         doc.accept @to
 
         list_verbatim
       end
-
     end
   end