lib/rdoc/markup/attribute_manager.rb

   1 require 'rdoc/markup/inline'
   2
   3 class RDoc::Markup::AttributeManager
   4
   5   NULL = "\000".freeze
   6
   7   ##
   8   # We work by substituting non-printing characters in to the text. For now
   9   # I'm assuming that I can substitute a character in the range 0..8 for a 7
  10   # bit character without damaging the encoded string, but this might be
  11   # optimistic
  12
  13   A_PROTECT  = 004
  14   PROTECT_ATTR  = A_PROTECT.chr
  15
  16   ##
  17   # This maps delimiters that occur around words (such as *bold* or +tt+)
  18   # where the start and end delimiters and the same. This lets us optimize
  19   # the regexp
  20
  21   MATCHING_WORD_PAIRS = {}
  22
  23   ##
  24   # And this is used when the delimiters aren't the same. In this case the
  25   # hash maps a pattern to the attribute character
  26
  27   WORD_PAIR_MAP = {}
  28
  29   ##
  30   # This maps HTML tags to the corresponding attribute char
  31
  32   HTML_TAGS = {}
  33
  34   ##
  35   # And this maps _special_ sequences to a name. A special sequence is
  36   # something like a WikiWord
  37
  38   SPECIAL = {}
  39
  40   ##
  41   # Return an attribute object with the given turn_on and turn_off bits set
  42
  43   def attribute(turn_on, turn_off)
  44     RDoc::Markup::AttrChanger.new turn_on, turn_off
  45   end
  46
  47   def change_attribute(current, new)
  48     diff = current ^ new
  49     attribute(new & diff, current & diff)
  50   end
  51
  52   def changed_attribute_by_name(current_set, new_set)
  53     current = new = 0
  54     current_set.each do |name|
  55       current |= RDoc::Markup::Attribute.bitmap_for(name)
  56     end
  57
  58     new_set.each do |name|
  59       new |= RDoc::Markup::Attribute.bitmap_for(name)
  60     end
  61
  62     change_attribute(current, new)
  63   end
  64
  65   def copy_string(start_pos, end_pos)
  66     res = @str[start_pos...end_pos]
  67     res.gsub!(/\000/, '')
  68     res
  69   end
  70
  71   ##
  72   # Map attributes like <b>text</b>to the sequence
  73   # \001\002<char>\001\003<char>, where <char> is a per-attribute specific
  74   # character
  75
  76   def convert_attrs(str, attrs)
  77     # first do matching ones
  78     tags = MATCHING_WORD_PAIRS.keys.join("")
  79
  80     re = /(^|\W)([#{tags}])([#:\\]?[\w.\/-]+?\S?)\2(\W|$)/
  81
  82     1 while str.gsub!(re) do
  83       attr = MATCHING_WORD_PAIRS[$2]
  84       attrs.set_attrs($`.length + $1.length + $2.length, $3.length, attr)
  85       $1 + NULL * $2.length + $3 + NULL * $2.length + $4
  86     end
  87
  88     # then non-matching
  89     unless WORD_PAIR_MAP.empty? then
  90       WORD_PAIR_MAP.each do |regexp, attr|
  91         str.gsub!(regexp) {
  92           attrs.set_attrs($`.length + $1.length, $2.length, attr)
  93           NULL * $1.length + $2 + NULL * $3.length
  94         }
  95       end
  96     end
  97   end
  98
  99   def convert_html(str, attrs)
 100     tags = HTML_TAGS.keys.join '|'
 101
 102     1 while str.gsub!(/<(#{tags})>(.*?)<\/\1>/i) {
 103       attr = HTML_TAGS[$1.downcase]
 104       html_length = $1.length + 2
 105       seq = NULL * html_length
 106       attrs.set_attrs($`.length + html_length, $2.length, attr)
 107       seq + $2 + seq + NULL
 108     }
 109   end
 110
 111   def convert_specials(str, attrs)
 112     unless SPECIAL.empty?
 113       SPECIAL.each do |regexp, attr|
 114         str.scan(regexp) do
 115           attrs.set_attrs($`.length, $&.length,
 116                           attr | RDoc::Markup::Attribute::SPECIAL)
 117         end
 118       end
 119     end
 120   end
 121
 122   ##
 123   # A \ in front of a character that would normally be processed turns off
 124   # processing. We do this by turning \< into <#{PROTECT}
 125
 126   PROTECTABLE = %w[<\\]
 127
 128   def mask_protected_sequences
 129     protect_pattern = Regexp.new("\\\\([#{Regexp.escape(PROTECTABLE.join(''))}])")
 130     @str.gsub!(protect_pattern, "\\1#{PROTECT_ATTR}")
 131   end
 132
 133   def unmask_protected_sequences
 134     @str.gsub!(/(.)#{PROTECT_ATTR}/, "\\1\000")
 135   end
 136
 137   def initialize
 138     add_word_pair("*", "*", :BOLD)
 139     add_word_pair("_", "_", :EM)
 140     add_word_pair("+", "+", :TT)
 141
 142     add_html("em", :EM)
 143     add_html("i",  :EM)
 144     add_html("b",  :BOLD)
 145     add_html("tt",   :TT)
 146     add_html("code", :TT)
 147   end
 148
 149   def add_word_pair(start, stop, name)
 150     raise ArgumentError, "Word flags may not start with '<'" if
 151       start[0,1] == '<'
 152
 153     bitmap = RDoc::Markup::Attribute.bitmap_for name
 154
 155     if start == stop then
 156       MATCHING_WORD_PAIRS[start] = bitmap
 157     else
 158       pattern = /(#{Regexp.escape start})(\S+)(#{Regexp.escape stop})/
 159       WORD_PAIR_MAP[pattern] = bitmap
 160     end
 161
 162     PROTECTABLE << start[0,1]
 163     PROTECTABLE.uniq!
 164   end
 165
 166   def add_html(tag, name)
 167     HTML_TAGS[tag.downcase] = RDoc::Markup::Attribute.bitmap_for name
 168   end
 169
 170   def add_special(pattern, name)
 171     SPECIAL[pattern] = RDoc::Markup::Attribute.bitmap_for name
 172   end
 173
 174   def flow(str)
 175     @str = str
 176
 177     mask_protected_sequences
 178
 179     @attrs = RDoc::Markup::AttrSpan.new @str.length
 180
 181     convert_attrs(@str, @attrs)
 182     convert_html(@str, @attrs)
 183     convert_specials(str, @attrs)
 184
 185     unmask_protected_sequences
 186
 187     return split_into_flow
 188   end
 189
 190   def display_attributes
 191     puts
 192     puts @str.tr(NULL, "!")
 193     bit = 1
 194     16.times do |bno|
 195       line = ""
 196       @str.length.times do |i|
 197         if (@attrs[i] & bit) == 0
 198           line << " "
 199         else
 200           if bno.zero?
 201             line << "S"
 202           else
 203             line << ("%d" % (bno+1))
 204           end
 205         end
 206       end
 207       puts(line) unless line =~ /^ *$/
 208       bit <<= 1
 209     end
 210   end
 211
 212   def split_into_flow
 213     res = []
 214     current_attr = 0
 215     str = ""
 216
 217     str_len = @str.length
 218
 219     # skip leading invisible text
 220     i = 0
 221     i += 1 while i < str_len and @str[i].chr == "\0"
 222     start_pos = i
 223
 224     # then scan the string, chunking it on attribute changes
 225     while i < str_len
 226       new_attr = @attrs[i]
 227       if new_attr != current_attr
 228         if i > start_pos
 229           res << copy_string(start_pos, i)
 230           start_pos = i
 231         end
 232
 233         res << change_attribute(current_attr, new_attr)
 234         current_attr = new_attr
 235
 236         if (current_attr & RDoc::Markup::Attribute::SPECIAL) != 0 then
 237           i += 1 while
 238             i < str_len and (@attrs[i] & RDoc::Markup::Attribute::SPECIAL) != 0
 239
 240           res << RDoc::Markup::Special.new(current_attr,
 241                                            copy_string(start_pos, i))
 242           start_pos = i
 243           next
 244         end
 245       end
 246
 247       # move on, skipping any invisible characters
 248       begin
 249         i += 1
 250       end while i < str_len and @str[i].chr == "\0"
 251     end
 252
 253     # tidy up trailing text
 254     if start_pos < str_len
 255       res << copy_string(start_pos, str_len)
 256     end
 257
 258     # and reset to all attributes off
 259     res << change_attribute(current_attr, 0) if current_attr != 0
 260
 261     return res
 262   end
 263
 264 end
 265