Class: RDoc::Markup::AttributeManager (Ruby 2.7.2)
Description: Class : RDoc::Markup::AttributeManager - Ruby 2.7.2

### Home Classes Methods

### In Files

- rdoc/markup/attribute_manager.rb

### Parent

Object

### Methods

- ::new
- #add_html
- #add_regexp_handling
- #add_word_pair
- #attribute
- #change_attribute
- #changed_attribute_by_name
- #convert_attrs
- #convert_html
- #convert_regexp_handlings
- #copy_string
- #display_attributes
- #flow
- #mask_protected_sequences
- #split_into_flow
- #unmask_protected_sequences

### Class/Module Index

Quicksearch

- InnerStateLex
- Object
- RDoc
- RDoc::Alias
- RDoc::AnonClass
- RDoc::AnyMethod
- RDoc::Attr
- RDoc::ClassModule
- RDoc::CodeObject
- RDoc::Comment
- RDoc::Constant
- RDoc::Context
- RDoc::Context::Section
- RDoc::CrossReference
- RDoc::ERBIO
- RDoc::ERBPartial
- RDoc::Encoding
- RDoc::Error
- RDoc::Extend
- RDoc::Generator
- RDoc::Generator::Darkfish
- RDoc::Generator::JsonIndex
- RDoc::Generator::Markup
- RDoc::Generator::POT
- RDoc::Generator::POT::MessageExtractor
- RDoc::Generator::POT::PO
- RDoc::Generator::POT::POEntry
- RDoc::Generator::RI
- RDoc::GhostMethod
- RDoc::I18n
- RDoc::I18n::Locale
- RDoc::I18n::Text
- RDoc::Include
- RDoc::Markdown
- RDoc::Markdown::Literals
- RDoc::Markup
- RDoc::Markup::AttrChanger
- RDoc::Markup::AttrSpan
- RDoc::Markup::AttributeManager
- RDoc::Markup::Attributes
- RDoc::Markup::BlankLine
- RDoc::Markup::BlockQuote
- RDoc::Markup::Document
- RDoc::Markup::Formatter
- RDoc::Markup::HardBreak
- RDoc::Markup::Include
- RDoc::Markup::IndentedParagraph
- RDoc::Markup::List
- RDoc::Markup::ListItem
- RDoc::Markup::Paragraph
- RDoc::Markup::Parser
- RDoc::Markup::Parser::Error
- RDoc::Markup::Parser::MyStringScanner
- RDoc::Markup::Parser::ParseError
- RDoc::Markup::PreProcess
- RDoc::Markup::Raw
- RDoc::Markup::RegexpHandling
- RDoc::Markup::Rule
- RDoc::Markup::ToAnsi
- RDoc::Markup::ToBs
- RDoc::Markup::ToHtml
- RDoc::Markup::ToHtmlCrossref
- RDoc::Markup::ToHtmlSnippet
- RDoc::Markup::ToJoinedParagraph
- RDoc::Markup::ToLabel
- RDoc::Markup::ToMarkdown
- RDoc::Markup::ToRdoc
- RDoc::Markup::ToTableOfContents
- RDoc::Markup::ToTest
- RDoc::Markup::ToTtOnly
- RDoc::Markup::Verbatim
- RDoc::MetaMethod
- RDoc::MethodAttr
- RDoc::Mixin
- RDoc::NormalClass
- RDoc::NormalModule
- RDoc::Options
- RDoc::Parser
- RDoc::Parser::C
- RDoc::Parser::ChangeLog
- RDoc::Parser::Markdown
- RDoc::Parser::RD
- RDoc::Parser::RipperStateLex
- RDoc::Parser::RipperStateLex::InnerStateLex
- RDoc::Parser::Ruby
- RDoc::Parser::RubyTools
- RDoc::Parser::Simple
- RDoc::Parser::Text
- RDoc::RD
- RDoc::RD::BlockParser
- RDoc::RD::Inline
- RDoc::RD::InlineParser
- RDoc::RDoc
- RDoc::RI
- RDoc::RI::Driver
- RDoc::RI::Driver::Error
- RDoc::RI::Driver::NotFoundError
- RDoc::RI::Error
- RDoc::RI::Paths
- RDoc::RI::Task
- RDoc::Require
- RDoc::RubygemsHook
- RDoc::Servlet
- RDoc::SingleClass
- RDoc::Stats
- RDoc::Stats::Normal
- RDoc::Stats::Quiet
- RDoc::Stats::Verbose
- RDoc::Store
- RDoc::Store::Error
- RDoc::Store::MissingFileError
- RDoc::Task
- RDoc::Text
- RDoc::TokenStream
- RDoc::TomDoc
- RDoc::TopLevel
- RDocTask

No matching classes.

# RDoc::Markup::AttributeManager

frozen_string_literal: true

Manages changes of attributes in a block of text

### Constants

NULL

  The NUL character

### Attributes

attributes[R]

The attributes enabled for this markup object.

html_tags[R]

This maps HTML tags to the corresponding attribute char

matching_word_pairs[R]

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

protectable[R]

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

regexp_handlings[R]

And this maps _regexp handling_ sequences to a name. A regexp handling sequence is something like a WikiWord

word_pair_map[R]

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

Creates a new attribute manager that understands bold, emphasized and teletype text.

                   # File rdoc/markup/attribute_manager.rb, line 65
    def initialize
      @html_tags = {}
      @matching_word_pairs = {}
      @protectable = %w[<]
      @regexp_handlings = []
      @word_pair_map = {}
      @attributes = RDoc::Markup::Attributes.new

      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

Adds a markup class with `name` for words surrounded by HTML tag `tag`. To process emphasis tags:

    am.add_html 'em', :EM

                   # File rdoc/markup/attribute_manager.rb, line 231
    def add_html(tag, name)
      @html_tags[tag.downcase] = @attributes.bitmap_for name
    end

add_regexp_handling(pattern, name) click to toggle source

Adds a regexp handling for `pattern` with `name`. A simple URL handler would be:

    @am.add_regexp_handling(/((https?:)\S+\w)/, :HYPERLINK)

                   # File rdoc/markup/attribute_manager.rb, line 241
    def add_regexp_handling pattern, name
      @regexp_handlings << [pattern, @attributes.bitmap_for(name)]
    end

add_word_pair(start, stop, name) click to toggle source

Adds a markup class with `name` for words wrapped in the `start` and `stop` character. To make words wrapped with “*” bold:

    am.add_word_pair '*', '*', :BOLD

                   # File rdoc/markup/attribute_manager.rb, line 208
    def add_word_pair(start, stop, name)
      raise ArgumentError, "Word flags may not start with '<'" if
        start[0,1] == '<'

      bitmap = @attributes.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 87
    def attribute(turn_on, turn_off)
      RDoc::Markup::AttrChanger.new turn_on, turn_off
    end

change_attribute(current, new) click to toggle source

Changes the current attribute from `current` to `new`

                   # File rdoc/markup/attribute_manager.rb, line 94
    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

Used by the tests to change attributes by name from `current_set` to `new_set`

                   # File rdoc/markup/attribute_manager.rb, line 103
    def changed_attribute_by_name current_set, new_set
      current = new = 0
      current_set.each do |name|
        current |= @attributes.bitmap_for(name)
      end

      new_set.each do |name|
        new |= @attributes.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 130
    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

Converts HTML tags to RDoc attributes

                   # File rdoc/markup/attribute_manager.rb, line 156
    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_regexp_handlings(str, attrs) click to toggle source

Converts regexp handling sequences to RDoc attributes

                   # File rdoc/markup/attribute_manager.rb, line 171
    def convert_regexp_handlings str, attrs
      @regexp_handlings.each do |regexp, attribute|
        str.scan(regexp) do
          capture = $~.size == 1 ? 0 : 1

          s, e = $~.offset capture

          attrs.set_attrs s, e - s, attribute | @attributes.regexp_handling
        end
      end
    end

copy_string(start_pos, end_pos) click to toggle source

Copies `start_pos` to `end_pos` from the current string

                   # File rdoc/markup/attribute_manager.rb, line 119
    def copy_string(start_pos, end_pos)
      res = @str[start_pos...end_pos]
      res.gsub!(/\000/, '')
      res
    end

display_attributes() click to toggle source

Debug method that prints a string along with its attributes

                   # File rdoc/markup/attribute_manager.rb, line 267
    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

Processes `str` converting attributes, HTML and regexp handlings

                   # File rdoc/markup/attribute_manager.rb, line 248
    def flow str
      @str = str.dup

      mask_protected_sequences

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

      convert_attrs            @str, @attrs
      convert_html             @str, @attrs
      convert_regexp_handlings @str, @attrs

      unmask_protected_sequences

      split_into_flow
    end

mask_protected_sequences() click to toggle source

Escapes regexp handling sequences of text to prevent conversion to RDoc

                   # File rdoc/markup/attribute_manager.rb, line 186
    def mask_protected_sequences
      # protect __send__, __FILE__, etc.
      @str.gsub!(/__([a-z]+)__/i,
        "_#{PROTECT_ATTR}_#{PROTECT_ATTR}\\1_#{PROTECT_ATTR}_#{PROTECT_ATTR}")
      @str.gsub!(/(\A|[^\])\([#{Regexp.escape @protectable.join}])/m,
                 "\\1\\2#{PROTECT_ATTR}")
      @str.gsub!(/\(\[#{Regexp.escape @protectable.join}])/m, "\\1")
    end

split_into_flow() click to toggle source

Splits the string into chunks by attribute change

                   # File rdoc/markup/attribute_manager.rb, line 292
    def split_into_flow
      res = []
      current_attr = 0

      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 & @attributes.regexp_handling) != 0 then
            i += 1 while
              i < str_len and (@attrs[i] & @attributes.regexp_handling) != 0

            res << RDoc::Markup::RegexpHandling.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

      res
    end

unmask_protected_sequences() click to toggle source

Unescapes regexp handling sequences of text

                   # File rdoc/markup/attribute_manager.rb, line 198
    def unmask_protected_sequences
      @str.gsub!(/(.)#{PROTECT_ATTR}/, "\\1\000")
    end