voloko-sdoc 0.1.7 → 0.1.9

data/rdoc/lib/rdoc/markup/fragments.rb

@@ -1,377 +0,0 @@
-require 'rdoc/markup'
-require 'rdoc/markup/lines'
-
-class RDoc::Markup
-
-  ##
-  # A Fragment is a chunk of text, subclassed as a paragraph, a list
-  # entry, or verbatim text.
-
-  class Fragment
-    attr_reader   :level, :param, :txt
-    attr_accessor :type
-
-    ##
-    # This is a simple factory system that lets us associate fragement
-    # types (a string) with a subclass of fragment
-
-    TYPE_MAP = {}
-
-    def self.type_name(name)
-      TYPE_MAP[name] = self
-    end
-
-    def self.for(line)
-      klass =  TYPE_MAP[line.type] ||
-        raise("Unknown line type: '#{line.type.inspect}:' '#{line.text}'")
-      return klass.new(line.level, line.param, line.flag, line.text)
-    end
-
-    def initialize(level, param, type, txt)
-      @level = level
-      @param = param
-      @type  = type
-      @txt   = ""
-      add_text(txt) if txt
-    end
-
-    def add_text(txt)
-      @txt << " " if @txt.length > 0
-      @txt << txt.tr_s("\n ", "  ").strip
-    end
-
-    def to_s
-      "L#@level: #{self.class.name.split('::')[-1]}\n#@txt"
-    end
-
-  end
-
-  ##
-  # A paragraph is a fragment which gets wrapped to fit. We remove all
-  # newlines when we're created, and have them put back on output.
-
-  class Paragraph < Fragment
-    type_name :PARAGRAPH
-  end
-
-  ##
-  # An empty line
-
-  class BlankLine < Paragraph
-    type_name :BLANK
-  end
-
-  ##
-  # A heading
-
-  class Heading < Paragraph
-    type_name :HEADING
-
-    ##
-    # Level of heading, smaller is more important
-
-    def head_level
-      @param.to_i
-    end
-
-  end
-
-  ##
-  # A List is a fragment with some kind of label
-
-  class ListBase < Paragraph
-    LIST_TYPES = [
-      :BULLET,
-      :NUMBER,
-      :UPPERALPHA,
-      :LOWERALPHA,
-      :LABELED,
-      :NOTE,
-    ]
-  end
-
-  ##
-  # An item in a list
-
-  class ListItem < ListBase
-    type_name :LIST
-
-    def to_s # :nodoc:
-      text = if [:NOTE, :LABELED].include? type then
-               "#{@param}: #{@txt}"
-             else
-               @txt
-             end
-
-      "L#@level: #{type} #{self.class.name.split('::')[-1]}\n#{text}"
-    end
-
-  end
-
-  ##
-  # Start of a list
-
-  class ListStart < ListBase
-
-    ##
-    # Creates a ListStart with nesting +level+
-
-    def initialize(level, param, type)
-      super(level, param, type, nil)
-    end
-  end
-
-  ##
-  # End of a list
-
-  class ListEnd < ListBase
-
-    ##
-    # Creates a ListEnd with nesting +level+
-
-    def initialize(level, type)
-      super(level, "", type, nil)
-    end
-  end
-
-  ##
-  # Verbatim code contains lines that don't get wrapped.
-
-  class Verbatim < Fragment
-    type_name  :VERBATIM
-
-    ##
-    # Adds +txt+ to this verbatim
-
-    def add_text(txt)
-      @txt << txt.chomp << "\n"
-    end
-
-  end
-
-  ##
-  # A horizontal rule
-
-  class Rule < Fragment
-    type_name :RULE
-  end
-
-  ##
-  # Collect groups of lines together. Each group will end up containing a flow
-  # of text.
-
-  class LineCollection
-
-    ##
-    # Creates a new collection of lines
-
-    def initialize
-      @fragments = []
-    end
-
-    ##
-    # Adds +fragment+ to the collection
-
-    def add(fragment)
-      @fragments << fragment
-    end
-
-    ##
-    # Iterates over the lines in the collection
-
-    def each(&b)
-      @fragments.each(&b)
-    end
-
-    def to_a # :nodoc:
-      @fragments.map {|fragment| fragment.to_s}
-    end
-
-    ##
-    # Factory for different fragment types
-
-    def fragment_for(*args)
-      Fragment.for(*args)
-    end
-
-    ##
-    # Tidy up at the end
-
-    def normalize
-      change_verbatim_blank_lines
-      add_list_start_and_ends
-      add_list_breaks
-      tidy_blank_lines
-    end
-
-    def to_s # :nodoc:
-      @fragments.join("\n----\n")
-    end
-
-    def accept(am, visitor)
-      visitor.start_accepting
-
-      @fragments.each do |fragment|
-        case fragment
-        when Verbatim
-          visitor.accept_verbatim(am, fragment)
-        when Rule
-          visitor.accept_rule(am, fragment)
-        when ListStart
-          visitor.accept_list_start(am, fragment)
-        when ListEnd
-          visitor.accept_list_end(am, fragment)
-        when ListItem
-          visitor.accept_list_item(am, fragment)
-        when BlankLine
-          visitor.accept_blank_line(am, fragment)
-        when Heading
-          visitor.accept_heading(am, fragment)
-        when Paragraph
-          visitor.accept_paragraph(am, fragment)
-        end
-      end
-
-      visitor.end_accepting
-    end
-
-    private
-
-    ##
-    # If you have:
-    #
-    #    normal paragraph text.
-    #
-    #       this is code
-    #   
-    #       and more code
-    #
-    # You'll end up with the fragments Paragraph, BlankLine, Verbatim,
-    # BlankLine, Verbatim, BlankLine, etc.
-    #
-    # The BlankLine in the middle of the verbatim chunk needs to be changed to
-    # a real verbatim newline, and the two verbatim blocks merged
-
-    def change_verbatim_blank_lines
-      frag_block = nil
-      blank_count = 0
-      @fragments.each_with_index do |frag, i|
-        if frag_block.nil?
-          frag_block = frag if Verbatim === frag
-        else
-          case frag
-          when Verbatim
-            blank_count.times { frag_block.add_text("\n") }
-            blank_count = 0
-            frag_block.add_text(frag.txt)
-            @fragments[i] = nil    # remove out current fragment
-          when BlankLine
-            if frag_block
-              blank_count += 1
-              @fragments[i] = nil
-            end
-          else
-            frag_block = nil
-            blank_count = 0
-          end
-        end
-      end
-      @fragments.compact!
-    end
-
-    ##
-    # List nesting is implicit given the level of indentation. Make it
-    # explicit, just to make life a tad easier for the output processors
-
-    def add_list_start_and_ends
-      level = 0
-      res = []
-      type_stack = []
-
-      @fragments.each do |fragment|
-        # $stderr.puts "#{level} : #{fragment.class.name} : #{fragment.level}"
-        new_level = fragment.level
-        while (level < new_level)
-          level += 1
-          type = fragment.type
-          res << ListStart.new(level, fragment.param, type) if type
-          type_stack.push type
-          # $stderr.puts "Start: #{level}"
-        end
-
-        while level > new_level
-          type = type_stack.pop
-          res << ListEnd.new(level, type) if type
-          level -= 1
-          # $stderr.puts "End: #{level}, #{type}"
-        end
-
-        res << fragment
-        level = fragment.level
-      end
-      level.downto(1) do |i|
-        type = type_stack.pop
-        res << ListEnd.new(i, type) if type
-      end
-
-      @fragments = res
-    end
-
-    ##
-    # Inserts start/ends between list entries at the same level that have
-    # different element types
-
-    def add_list_breaks
-      res = @fragments
-
-      @fragments = []
-      list_stack = []
-
-      res.each do |fragment|
-        case fragment
-        when ListStart
-          list_stack.push fragment
-        when ListEnd
-          start = list_stack.pop
-          fragment.type = start.type
-        when ListItem
-          l = list_stack.last
-          if fragment.type != l.type
-            @fragments << ListEnd.new(l.level, l.type)
-            start = ListStart.new(l.level, fragment.param, fragment.type)
-            @fragments << start
-            list_stack.pop
-            list_stack.push start
-          end
-        else
-          ;
-        end
-        @fragments << fragment
-      end
-    end
-
-    ##
-    # Tidy up the blank lines:
-    # * change Blank/ListEnd into ListEnd/Blank
-    # * remove blank lines at the front
-
-    def tidy_blank_lines
-      (@fragments.size - 1).times do |i|
-        if BlankLine === @fragments[i] and ListEnd === @fragments[i+1] then
-          @fragments[i], @fragments[i+1] = @fragments[i+1], @fragments[i]
-        end
-      end
-
-      # remove leading blanks
-      @fragments.each_with_index do |f, i|
-        break unless f.kind_of? BlankLine
-        @fragments[i] = nil
-      end
-
-      @fragments.compact!
-    end
-
-  end
-
-end
-

data/rdoc/lib/rdoc/markup/inline.rb

@@ -1,126 +0,0 @@
-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 # :nodoc:
-      "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
-
-    ##
-    # Creates a new AttrSpan for +length+ characters
-
-    def initialize(length)
-      @attrs = Array.new(length, 0)
-    end
-
-    ##
-    # Toggles +bits+ from +start+ to +length+
-    def set_attrs(start, length, bits)
-      for i in start ... (start+length)
-        @attrs[i] |= bits
-      end
-    end
-
-    ##
-    # Acccesses flags for character +n+
-
-    def [](n)
-      @attrs[n]
-    end
-
-  end
-
-  ##
-  # Hold details of a special sequence
-
-  class Special
-
-    ##
-    # Special type
-
-    attr_reader   :type
-
-    ##
-    # Special text
-
-    attr_accessor :text
-
-    ##
-    # Creates a new special sequence of +type+ with +text+
-
-    def initialize(type, text)
-      @type, @text = type, text
-    end
-
-    ##
-    # Specials are equal when the have the same text and type
-
-    def ==(o)
-      self.text == o.text && self.type == o.type
-    end
-
-    def inspect # :nodoc:
-      "#<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 # :nodoc:
-      "Special: type=#{type}, name=#{RDoc::Markup::Attribute.as_string type}, text=#{text.dump}"
-    end
-
-  end
-
-end
-
-require 'rdoc/markup/attribute_manager'

data/rdoc/lib/rdoc/markup/lines.rb

@@ -1,156 +0,0 @@
-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
-    
-    ##
-    # Not really
-
-    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
-