rdoc 2.0.0

data/lib/rdoc/markup/inline.rb

@@ -0,0 +1,101 @@
+require 'rdoc/markup'
+
+class RDoc::Markup
+
+  ##
+  # We manage a set of attributes. Each attribute has a symbol name and a bit
+  # value.
+
+  class Attribute
+    SPECIAL = 1
+
+    @@name_to_bitmap = { :_SPECIAL_ => SPECIAL }
+    @@next_bitmap = 2
+
+    def self.bitmap_for(name)
+      bitmap = @@name_to_bitmap[name]
+      unless bitmap then
+        bitmap = @@next_bitmap
+        @@next_bitmap <<= 1
+        @@name_to_bitmap[name] = bitmap
+      end
+      bitmap
+    end
+
+    def self.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
+
+    def self.each_name_of(bitmap)
+      @@name_to_bitmap.each do |name, bit|
+        next if bit == SPECIAL
+        yield name.to_s if (bitmap & bit) != 0
+      end
+    end
+  end
+
+  AttrChanger = Struct.new(:turn_on, :turn_off)
+
+  ##
+  # An AttrChanger records a change in attributes. It contains a bitmap of the
+  # attributes to turn on, and a bitmap of those to turn off.
+
+  class AttrChanger
+    def to_s
+      "Attr: +#{Attribute.as_string(@turn_on)}/-#{Attribute.as_string(@turn_on)}"
+    end
+  end
+
+  ##
+  # An array of attributes which parallels the characters in a string.
+
+  class AttrSpan
+    def initialize(length)
+      @attrs = Array.new(length, 0)
+    end
+
+    def set_attrs(start, length, bits)
+      for i in start ... (start+length)
+        @attrs[i] |= bits
+      end
+    end
+
+    def [](n)
+      @attrs[n]
+    end
+  end
+
+  ##
+  # Hold details of a special sequence
+
+  class Special
+    attr_reader   :type
+    attr_accessor :text
+
+    def initialize(type, text)
+      @type, @text = type, text
+    end
+
+    def ==(o)
+      self.text == o.text && self.type == o.type
+    end
+
+    def inspect
+      "#<RDoc::Markup::Special:0x%x @type=%p, name=%p @text=%p>" % [
+        object_id, @type, RDoc::Markup::Attribute.as_string(type), text.dump]
+    end
+
+    def to_s
+      "Special: type=#{type}, name=#{RDoc::Markup::Attribute.as_string type}, text=#{text.dump}"
+    end
+
+  end
+
+end
+
+require 'rdoc/markup/attribute_manager'

data/lib/rdoc/markup/lines.rb

@@ -0,0 +1,152 @@
+class RDoc::Markup
+
+  ##
+  # We store the lines we're working on as objects of class Line.  These
+  # contain the text of the line, along with a flag indicating the line type,
+  # and an indentation level.
+
+  class Line
+    INFINITY = 9999
+
+    LINE_TYPES = [
+      :BLANK,
+      :HEADING,
+      :LIST,
+      :PARAGRAPH,
+      :RULE,
+      :VERBATIM,
+    ]
+
+    # line type
+    attr_accessor :type
+
+    # The indentation nesting level
+    attr_accessor :level
+
+    # The contents
+    attr_accessor :text
+
+    # A prefix or parameter. For LIST lines, this is
+    # the text that introduced the list item (the label)
+    attr_accessor  :param
+
+    # A flag. For list lines, this is the type of the list
+    attr_accessor :flag
+
+    # the number of leading spaces
+    attr_accessor :leading_spaces
+
+    # true if this line has been deleted from the list of lines
+    attr_accessor :deleted
+
+    def initialize(text)
+      @text    = text.dup
+      @deleted = false
+
+      # expand tabs
+      1 while @text.gsub!(/\t+/) { ' ' * (8*$&.length - $`.length % 8)}  && $~ #`
+
+      # Strip trailing whitespace
+      @text.sub!(/\s+$/, '')
+
+      # and look for leading whitespace
+      if @text.length > 0
+        @text =~ /^(\s*)/
+        @leading_spaces = $1.length
+      else
+        @leading_spaces = INFINITY
+      end
+    end
+
+    # Return true if this line is blank
+    def blank?
+      @text.empty?
+    end
+
+    # stamp a line with a type, a level, a prefix, and a flag
+    def stamp(type, level, param="", flag=nil)
+      @type, @level, @param, @flag = type, level, param, flag
+    end
+
+    ##
+    # Strip off the leading margin
+
+    def strip_leading(size)
+      if @text.size > size
+        @text[0,size] = ""
+      else
+        @text = ""
+      end
+    end
+
+    def to_s
+      "#@type#@level: #@text"
+    end
+  end
+
+  ##
+  # A container for all the lines.
+
+  class Lines
+
+    include Enumerable
+
+    attr_reader :lines # :nodoc:
+
+    def initialize(lines)
+      @lines = lines
+      rewind
+    end
+
+    def empty?
+      @lines.size.zero?
+    end
+
+    def each
+      @lines.each do |line|
+        yield line unless line.deleted
+      end
+    end
+
+#    def [](index)
+#      @lines[index]
+#    end
+
+    def rewind
+      @nextline = 0
+    end
+
+    def next
+      begin
+        res = @lines[@nextline]
+        @nextline += 1 if @nextline < @lines.size
+      end while res and res.deleted and @nextline < @lines.size
+      res
+    end
+
+    def unget
+      @nextline -= 1
+    end
+
+    def delete(a_line)
+      a_line.deleted = true
+    end
+
+    def normalize
+      margin = @lines.collect{|l| l.leading_spaces}.min
+      margin = 0 if margin == :INFINITY
+      @lines.each {|line| line.strip_leading(margin) } if margin > 0
+    end
+
+    def as_text
+      @lines.map {|l| l.text}.join("\n")
+    end
+
+    def line_types
+      @lines.map {|l| l.type }
+    end
+
+  end
+
+end
+

data/lib/rdoc/markup/preprocess.rb

@@ -0,0 +1,71 @@
+require 'rdoc/markup'
+
+##
+# Handle common directives that can occur in a block of text:
+#
+# : include : filename
+
+class RDoc::Markup::PreProcess
+
+  def initialize(input_file_name, include_path)
+    @input_file_name = input_file_name
+    @include_path = include_path
+  end
+
+  ##
+  # Look for common options in a chunk of text. Options that we don't handle
+  # are passed back to our caller as |directive, param|
+
+  def handle(text)
+    text.gsub!(/^([ \t#]*):(\w+):\s*(.+)?\n/) do
+      prefix    = $1
+      directive = $2.downcase
+      param     = $3
+
+      case directive
+      when "include"
+        filename = param.split[0]
+        include_file(filename, prefix)
+
+      else
+        yield(directive, param)
+      end
+    end
+  end
+
+  private
+
+  ##
+  # Include a file, indenting it correctly.
+
+  def include_file(name, indent)
+    if full_name = find_include_file(name) then
+      content = File.open(full_name) {|f| f.read}
+      # strip leading '#'s, but only if all lines start with them
+      if content =~ /^[^#]/
+        content.gsub(/^/, indent)
+      else
+        content.gsub(/^#?/, indent)
+      end
+    else
+      $stderr.puts "Couldn't find file to include: '#{name}'"
+      ''
+    end
+  end
+
+  ##
+  # Look for the given file in the directory containing the current file,
+  # and then in each of the directories specified in the RDOC_INCLUDE path
+
+  def find_include_file(name)
+    to_search = [ File.dirname(@input_file_name) ].concat @include_path
+    to_search.each do |dir|
+      full_name = File.join(dir, name)
+      stat = File.stat(full_name) rescue next
+      return full_name if stat.readable?
+    end
+    nil
+  end
+
+end
+

data/lib/rdoc/markup/to_flow.rb

@@ -0,0 +1,185 @@
+require 'rdoc/markup/formatter'
+require 'rdoc/markup/fragments'
+require 'rdoc/markup/inline'
+require 'cgi'
+
+class RDoc::Markup
+
+  module Flow
+    P = Struct.new(:body)
+    VERB = Struct.new(:body)
+    RULE = Struct.new(:width)
+    class LIST
+      attr_reader :type, :contents
+      def initialize(type)
+        @type = type
+        @contents = []
+      end
+      def <<(stuff)
+        @contents << stuff
+      end
+    end
+    LI = Struct.new(:label, :body)
+    H = Struct.new(:level, :text)
+  end
+
+  class ToFlow < RDoc::Markup::Formatter
+    LIST_TYPE_TO_HTML = {
+      :BULLET     =>  [ "<ul>", "</ul>" ],
+      :NUMBER     =>  [ "<ol>", "</ol>" ],
+      :UPPERALPHA =>  [ "<ol>", "</ol>" ],
+      :LOWERALPHA =>  [ "<ol>", "</ol>" ],
+      :LABELED    =>  [ "<dl>", "</dl>" ],
+      :NOTE       =>  [ "<table>", "</table>" ],
+    }
+
+    InlineTag = Struct.new(:bit, :on, :off)
+
+    def initialize
+      super
+
+      init_tags
+    end
+
+    ##
+    # Set up the standard mapping of attributes to HTML tags
+
+    def init_tags
+      @attr_tags = [
+        InlineTag.new(RDoc::Markup::Attribute.bitmap_for(:BOLD), "<b>", "</b>"),
+        InlineTag.new(RDoc::Markup::Attribute.bitmap_for(:TT),   "<tt>", "</tt>"),
+        InlineTag.new(RDoc::Markup::Attribute.bitmap_for(:EM),   "<em>", "</em>"),
+      ]
+    end
+
+    ##
+    # Add a new set of HTML tags for an attribute. We allow separate start and
+    # end tags for flexibility
+
+    def add_tag(name, start, stop)
+      @attr_tags << InlineTag.new(RDoc::Markup::Attribute.bitmap_for(name), start, stop)
+    end
+
+    ##
+    # Given an HTML tag, decorate it with class information and the like if
+    # required. This is a no-op in the base class, but is overridden in HTML
+    # output classes that implement style sheets
+
+    def annotate(tag)
+      tag
+    end
+
+    ##
+    # Here's the client side of the visitor pattern
+
+    def start_accepting
+      @res = []
+      @list_stack = []
+    end
+
+    def end_accepting
+      @res
+    end
+
+    def accept_paragraph(am, fragment)
+      @res << Flow::P.new((convert_flow(am.flow(fragment.txt))))
+    end
+
+    def accept_verbatim(am, fragment)
+      @res << Flow::VERB.new((convert_flow(am.flow(fragment.txt))))
+    end
+
+    def accept_rule(am, fragment)
+      size = fragment.param
+      size = 10 if size > 10
+      @res << Flow::RULE.new(size)
+    end
+
+    def accept_list_start(am, fragment)
+      @list_stack.push(@res)
+      list = Flow::LIST.new(fragment.type)
+      @res << list
+      @res = list
+    end
+
+    def accept_list_end(am, fragment)
+      @res = @list_stack.pop
+    end
+
+    def accept_list_item(am, fragment)
+      @res << Flow::LI.new(fragment.param, convert_flow(am.flow(fragment.txt)))
+    end
+
+    def accept_blank_line(am, fragment)
+      # @res << annotate("<p />") << "\n"
+    end
+
+    def accept_heading(am, fragment)
+      @res << Flow::H.new(fragment.head_level, convert_flow(am.flow(fragment.txt)))
+    end
+
+    private
+
+    def on_tags(res, item)
+      attr_mask = item.turn_on
+      return if attr_mask.zero?
+
+      @attr_tags.each do |tag|
+        if attr_mask & tag.bit != 0
+          res << annotate(tag.on)
+        end
+      end
+    end
+
+    def off_tags(res, item)
+      attr_mask = item.turn_off
+      return if attr_mask.zero?
+
+      @attr_tags.reverse_each do |tag|
+        if attr_mask & tag.bit != 0
+          res << annotate(tag.off)
+        end
+      end
+    end
+
+    def convert_flow(flow)
+      res = ""
+      flow.each do |item|
+        case item
+        when String
+          res << convert_string(item)
+        when AttrChanger
+          off_tags(res, item)
+          on_tags(res,  item)
+        when Special
+          res << convert_special(item)
+        else
+          raise "Unknown flow element: #{item.inspect}"
+        end
+      end
+      res
+    end
+
+    def convert_string(item)
+      CGI.escapeHTML(item)
+    end
+
+    def convert_special(special)
+      handled = false
+      Attribute.each_name_of(special.type) do |name|
+        method_name = "handle_special_#{name}"
+        if self.respond_to? method_name
+          special.text = send(method_name, special)
+          handled = true
+        end
+      end
+
+      raise "Unhandled special: #{special}" unless handled
+
+      special.text
+    end
+
+  end
+
+end
+