sqlpostgres 1.2.4

data/tools/rdoc/markup/simple_markup/inline.rb

@@ -0,0 +1,348 @@
+module SM
+
+  # 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 Attribute.bitmap_for(name)
+      bitmap = @@name_to_bitmap[name]
+      if !bitmap
+        bitmap = @@next_bitmap
+        @@next_bitmap <<= 1
+        @@name_to_bitmap[name] = bitmap
+      end
+      bitmap
+    end
+
+    def Attribute.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 Attribute.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
+
+
+  # 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
+
+  AttrChanger = Struct.new(:turn_on, :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 to_s
+      "Special: type=#{type}, text=#{text.dump}"
+    end
+  end
+  
+  class AttributeManager
+
+    NULL = "\000".freeze
+
+    ##
+    # 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
+    #
+
+=begin
+    ATTR_FLAG  = 001
+    A_START    = 002
+    A_END      = 003
+    A_SPECIAL_START = 005
+    A_SPECIAL_END   = 006
+
+    START_ATTR   = ATTR_FLAG.chr + A_START.chr
+    END_ATTR     = ATTR_FLAG.chr + A_END.chr
+
+    START_SPECIAL = ATTR_FLAG.chr + A_SPECIAL_START.chr
+    END_SPECIAL   = ATTR_FLAG.chr + A_SPECIAL_END.chr
+
+=end
+    A_PROTECT  = 004
+    PROTECT_ATTR  = A_PROTECT.chr
+
+    # 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
+    MATCHING_WORD_PAIRS = {}
+
+    # And this is used when the delimiters aren't the same. In this
+    # case the hash maps a pattern to the attribute character
+    WORD_PAIR_MAP = {}
+
+    # This maps HTML tags to the corresponding attribute char
+    HTML_TAGS = {}
+
+    # And this maps _special_ sequences to a name. A special sequence
+    # is something like a WikiWord
+    SPECIAL = {}
+
+    # Return an attribute object with the given turn_on
+    # and turn_off bits set
+
+    def attribute(turn_on, turn_off)
+      AttrChanger.new(turn_on, turn_off)
+    end
+
+
+    def change_attribute(current, new)
+      diff = current ^ new
+      attribute(new & diff, current & diff)
+    end
+
+    def changed_attribute_by_name(current_set, new_set)
+      current = new = 0
+      current_set.each {|name| current |= Attribute.bitmap_for(name) }
+      new_set.each {|name| new |= Attribute.bitmap_for(name) }
+      change_attribute(current, new)
+    end
+
+    def copy_string(start_pos, end_pos)
+      res = @str[start_pos...end_pos]
+      res.gsub!(/\000/, '')
+      res
+    end
+
+    # Map attributes like <b>text</b>to the sequence \001\002<char>\001\003<char>,
+    # where <char> is a per-attribute specific character
+
+    def convert_attrs(str, attrs)
+      # first do matching ones
+      tags = MATCHING_WORD_PAIRS.keys.join("")
+      re = "(^|\\W)([#{tags}])([A-Za-z_]+?)\\2(\\W|\$)"
+#      re = "(^|\\W)([#{tags}])(\\S+?)\\2(\\W|\$)"
+      1 while str.gsub!(Regexp.new(re)) {
+        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
+      }
+
+      # then non-matching
+      unless WORD_PAIR_MAP.empty?
+        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
+
+    def convert_html(str, attrs)
+      tags = HTML_TAGS.keys.join("|")
+      re = "<(#{tags})>(.*?)</\\1>"
+      1 while str.gsub!(Regexp.new(re, Regexp::IGNORECASE)) {
+        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
+
+    def convert_specials(str, attrs)
+      unless SPECIAL.empty?
+        SPECIAL.each do |regexp, attr|
+          str.scan(regexp) do
+            attrs.set_attrs($`.length, $1.length, attr | Attribute::SPECIAL)
+          end
+        end
+      end
+    end
+
+    # A \ in front of a character that would normally be
+    # processed turns off processing. We do this by turning
+    # \< into <#{PROTECT}
+    
+    PROTECTABLE = [ "<" << "\\" ]  #"
+
+
+    def mask_protected_sequences
+      protect_pattern = Regexp.new("\\\\([#{Regexp.escape(PROTECTABLE.join(''))}])")
+      @str.gsub!(protect_pattern, "\\1#{PROTECT_ATTR}")
+    end
+
+    def unmask_protected_sequences
+      @str.gsub!(/(.)#{PROTECT_ATTR}/, '\1')
+    end
+
+    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)
+    end
+
+    def add_word_pair(start, stop, name)
+      raise "Word flags may not start '<'" if start[0] == ?<
+      bitmap = Attribute.bitmap_for(name)
+      if start == stop
+        MATCHING_WORD_PAIRS[start] = bitmap
+      else
+        pattern = Regexp.new("(" + Regexp.escape(start) + ")" +
+#                             "([A-Za-z]+)" +
+                             "(\\S+)" +
+                             "(" + Regexp.escape(stop) +")")
+        WORD_PAIR_MAP[pattern] = bitmap
+      end
+      PROTECTABLE << start[0,1]
+      PROTECTABLE.uniq!
+    end
+
+    def add_html(tag, name)
+      HTML_TAGS[tag.downcase] = Attribute.bitmap_for(name)
+    end
+
+    def add_special(pattern, name)
+      SPECIAL[pattern] = Attribute.bitmap_for(name)
+    end
+
+    def flow(str)
+      @str = str
+      @attrs = AttrSpan.new(str.length)
+
+      puts("Before flow, str='#{@str.dump}'") if $DEBUG
+      mask_protected_sequences
+      convert_attrs(@str, @attrs)
+      convert_html(@str, @attrs)
+      convert_specials(str, @attrs)
+      unmask_protected_sequences
+      puts("After flow, str='#{@str.dump}'") if $DEBUG
+      return split_into_flow
+    end
+
+    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
+
+    def split_into_flow
+
+      display_attributes if $DEBUG
+
+      res = []
+      current_attr = 0
+      str = ""
+
+      
+      str_len = @str.length
+
+      # skip leading invisible text
+      i = 0
+      i += 1 while i < str_len and @str[i].zero?
+      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 & Attribute::SPECIAL) != 0
+            i += 1 while i < str_len and (@attrs[i] & Attribute::SPECIAL) != 0
+            res << 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].zero?
+      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
+
+  end
+
+end

data/tools/rdoc/markup/simple_markup/lines.rb

@@ -0,0 +1,147 @@
+##########################################################################
+#
+# 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
+
+module SM
+
+  class Line
+    INFINITY = 9999
+
+    BLANK     = :BLANK
+    HEADING   = :HEADING
+    LIST      = :LIST
+    RULE      = :RULE
+    PARAGRAPH = :PARAGRAPH
+    VERBATIM  = :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 isBlank?
+      @text.length.zero?
+    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)
+      @text[0,size] = ""
+    end
+
+    def to_s
+      "#@type#@level: #@text"
+    end
+  end
+
+  ###############################################################################
+  #
+  # A container for all the lines
+  #
+
+  class Lines
+    include Enumerable
+
+    attr_reader :lines   # for debugging
+
+    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 == Line::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/tools/rdoc/markup/simple_markup/preprocess.rb

@@ -0,0 +1,68 @@
+module SM
+
+  ## 
+  # Handle common directives that can occur in a block of text:
+  #
+  # : include : filename
+  #
+
+  class 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 
+
+        directive = $2.downcase
+        param     = $3
+
+        case directive
+
+        when "include"
+          include_file($3, $1)
+
+        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))
+        content = File.open(full_name) {|f| f.read}
+        res = content.gsub(/^#?/, indent)
+      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
+end