In Files

  • rdoc/markup/attribute_manager.rb

Files

Class/Module Index [+]

Quicksearch

RDoc::Markup::AttributeManager

Constants

A_PROTECT

We work by substituting non-printing characters in to the text. For now I’m assuming that I can substitute a character in the range 0..8 for a 7 bit character without damaging the encoded string, but this might be optimistic

HTML_TAGS

This maps HTML tags to the corresponding attribute char

MATCHING_WORD_PAIRS

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 the regexp

NULL
PROTECTABLE

A \ in front of a character that would normally be processed turns off processing. We do this by turning < into <#{PROTECT}

PROTECT_ATTR
SPECIAL

And this maps special sequences to a name. A special sequence is something like a WikiWord

WORD_PAIR_MAP

And this is used when the delimiters aren’t the same. In this case the hash maps a pattern to the attribute character

Public Class Methods

new() click to toggle source
 
               # File rdoc/markup/attribute_manager.rb, line 137
def initialize
  add_word_pair("*", "*", :BOLD)
  add_word_pair("_", "_", :EM)
  add_word_pair("+", "+", :TT)

  add_html("em", :EM)
  add_html("i",  :EM)
  add_html("b",  :BOLD)
  add_html("tt",   :TT)
  add_html("code", :TT)
end
            

Public Instance Methods

add_html(tag, name) click to toggle source
 
               # File rdoc/markup/attribute_manager.rb, line 166
def add_html(tag, name)
  HTML_TAGS[tag.downcase] = RDoc::Markup::Attribute.bitmap_for name
end
            
add_special(pattern, name) click to toggle source
 
               # File rdoc/markup/attribute_manager.rb, line 170
def add_special(pattern, name)
  SPECIAL[pattern] = RDoc::Markup::Attribute.bitmap_for name
end
            
add_word_pair(start, stop, name) click to toggle source
 
               # File rdoc/markup/attribute_manager.rb, line 149
def add_word_pair(start, stop, name)
  raise ArgumentError, "Word flags may not start with '<'" if
    start[0,1] == '<'

  bitmap = RDoc::Markup::Attribute.bitmap_for name

  if start == stop then
    MATCHING_WORD_PAIRS[start] = bitmap
  else
    pattern = /(#{Regexp.escape start})(\S+)(#{Regexp.escape stop})/
    WORD_PAIR_MAP[pattern] = bitmap
  end

  PROTECTABLE << start[0,1]
  PROTECTABLE.uniq!
end
            
attribute(turn_on, turn_off) click to toggle source

Return an attribute object with the given turn_on and turn_off bits set

 
               # File rdoc/markup/attribute_manager.rb, line 43
def attribute(turn_on, turn_off)
  RDoc::Markup::AttrChanger.new turn_on, turn_off
end
            
change_attribute(current, new) click to toggle source
 
               # File rdoc/markup/attribute_manager.rb, line 47
def change_attribute(current, new)
  diff = current ^ new
  attribute(new & diff, current & diff)
end
            
changed_attribute_by_name(current_set, new_set) click to toggle source
 
               # File rdoc/markup/attribute_manager.rb, line 52
def changed_attribute_by_name(current_set, new_set)
  current = new = 0
  current_set.each do |name|
    current |= RDoc::Markup::Attribute.bitmap_for(name)
  end

  new_set.each do |name|
    new |= RDoc::Markup::Attribute.bitmap_for(name)
  end

  change_attribute(current, new)
end
            
convert_attrs(str, attrs) click to toggle source

Map attributes like textto the sequence 001002<char>001003<char>, where <char> is a per-attribute specific character

 
               # File rdoc/markup/attribute_manager.rb, line 76
def convert_attrs(str, attrs)
  # first do matching ones
  tags = MATCHING_WORD_PAIRS.keys.join("")

  re = /(^|\W)([#{tags}])([#:\]?[\w.\/-]+?\S?)\2(\W|$)/

  1 while str.gsub!(re) do
    attr = MATCHING_WORD_PAIRS[$2]
    attrs.set_attrs($`.length + $1.length + $2.length, $3.length, attr)
    $1 + NULL * $2.length + $3 + NULL * $2.length + $4
  end

  # then non-matching
  unless WORD_PAIR_MAP.empty? then
    WORD_PAIR_MAP.each do |regexp, attr|
      str.gsub!(regexp) {
        attrs.set_attrs($`.length + $1.length, $2.length, attr)
        NULL * $1.length + $2 + NULL * $3.length
      }
    end
  end
end
            
convert_html(str, attrs) click to toggle source
 
               # File rdoc/markup/attribute_manager.rb, line 99
def convert_html(str, attrs)
  tags = HTML_TAGS.keys.join '|'

  1 while str.gsub!(/<(#{tags})>(.*?)<\/\1>/i) {
    attr = HTML_TAGS[$1.downcase]
    html_length = $1.length + 2
    seq = NULL * html_length
    attrs.set_attrs($`.length + html_length, $2.length, attr)
    seq + $2 + seq + NULL
  }
end
            
convert_specials(str, attrs) click to toggle source
 
               # File rdoc/markup/attribute_manager.rb, line 111
def convert_specials(str, attrs)
  unless SPECIAL.empty?
    SPECIAL.each do |regexp, attr|
      str.scan(regexp) do
        attrs.set_attrs($`.length, $&.length,
                        attr | RDoc::Markup::Attribute::SPECIAL)
      end
    end
  end
end
            
copy_string(start_pos, end_pos) click to toggle source
 
               # File rdoc/markup/attribute_manager.rb, line 65
def copy_string(start_pos, end_pos)
  res = @str[start_pos...end_pos]
  res.gsub!(/\000/, '')
  res
end
            
display_attributes() click to toggle source
 
               # File rdoc/markup/attribute_manager.rb, line 190
def display_attributes
  puts
  puts @str.tr(NULL, "!")
  bit = 1
  16.times do |bno|
    line = ""
    @str.length.times do |i|
      if (@attrs[i] & bit) == 0
        line << " "
      else
        if bno.zero?
          line << "S"
        else
          line << ("%d" % (bno+1))
        end
      end
    end
    puts(line) unless line =~ /^ *$/
    bit <<= 1
  end
end
            
flow(str) click to toggle source
 
               # File rdoc/markup/attribute_manager.rb, line 174
def flow(str)
  @str = str

  mask_protected_sequences

  @attrs = RDoc::Markup::AttrSpan.new @str.length

  convert_attrs(@str, @attrs)
  convert_html(@str, @attrs)
  convert_specials(str, @attrs)

  unmask_protected_sequences

  return split_into_flow
end
            
mask_protected_sequences() click to toggle source
 
               # File rdoc/markup/attribute_manager.rb, line 128
def mask_protected_sequences
  protect_pattern = Regexp.new("\\\\([#{Regexp.escape(PROTECTABLE.join(''))}])")
  @str.gsub!(protect_pattern, "\\1#{PROTECT_ATTR}")
end
            
split_into_flow() click to toggle source
 
               # File rdoc/markup/attribute_manager.rb, line 212
def split_into_flow
  res = []
  current_attr = 0
  str = ""

  str_len = @str.length

  # skip leading invisible text
  i = 0
  i += 1 while i < str_len and @str[i].chr == "\0"
  start_pos = i

  # then scan the string, chunking it on attribute changes
  while i < str_len
    new_attr = @attrs[i]
    if new_attr != current_attr
      if i > start_pos
        res << copy_string(start_pos, i)
        start_pos = i
      end

      res << change_attribute(current_attr, new_attr)
      current_attr = new_attr

      if (current_attr & RDoc::Markup::Attribute::SPECIAL) != 0 then
        i += 1 while
          i < str_len and (@attrs[i] & RDoc::Markup::Attribute::SPECIAL) != 0

        res << RDoc::Markup::Special.new(current_attr,
                                         copy_string(start_pos, i))
        start_pos = i
        next
      end
    end

    # move on, skipping any invisible characters
    begin
      i += 1
    end while i < str_len and @str[i].chr == "\0"
  end

  # tidy up trailing text
  if start_pos < str_len
    res << copy_string(start_pos, str_len)
  end

  # and reset to all attributes off
  res << change_attribute(current_attr, 0) if current_attr != 0

  return res
end
            
unmask_protected_sequences() click to toggle source
 
               # File rdoc/markup/attribute_manager.rb, line 133
def unmask_protected_sequences
  @str.gsub!(/(.)#{PROTECT_ATTR}/, "\\1\000")
end
            

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please visit Documenting-ruby.org.

blog comments powered by Disqus