sqlpostgres 1.2.4

data/tools/rdoc/install.rb

@@ -0,0 +1,137 @@
+require 'rbconfig'
+require 'find'
+require 'ftools'
+
+include Config
+
+$ruby = CONFIG['ruby_install_name']
+
+##
+# Install a binary file. We patch in on the way through to
+# insert a #! line. If this is a Unix install, we name
+# the command (for example) 'rdoc' and let the shebang line
+# handle running it. Under windows, we add a '.rb' extension
+# and let file associations to their stuff
+#
+
+def installBIN(from, opfile)
+
+  tmp_dir = nil
+  for t in [".", "/tmp", "c:/temp", $bindir]
+    stat = File.stat(t) rescue next
+    if stat.directory? and stat.writable?
+      tmp_dir = t
+      break
+    end
+  end
+
+  fail "Cannot find a temporary directory" unless tmp_dir
+  tmp_file = File.join(tmp_dir, "_tmp")
+    
+    
+  File.open(from) do |ip|
+    File.open(tmp_file, "w") do |op|
+      ruby = File.join($realbindir, $ruby)
+      op.puts "#!#{ruby}"
+      op.write ip.read
+    end
+  end
+
+  opfile += ".rb" if CONFIG["target_os"] =~ /mswin/i
+  File::install(tmp_file, File.join($bindir, opfile), 0755, true)
+  File::unlink(tmp_file)
+end
+
+
+
+
+
+$sitedir = CONFIG["rubylibdir"]
+unless $sitedir
+  version = CONFIG["MAJOR"]+"."+CONFIG["MINOR"]
+  $libdir = File.join(CONFIG["libdir"], "ruby", version)
+  $sitedir = $:.find {|x| x =~ /site_ruby/}
+  if !$sitedir
+    $sitedir = File.join($libdir, "site_ruby")
+  elsif $sitedir !~ Regexp.quote(version)
+    $sitedir = File.join($sitedir, version)
+  end
+end
+
+$bindir =  CONFIG["bindir"]
+
+$realbindir = $bindir
+
+bindir = CONFIG["bindir"]
+if (destdir = ENV['DESTDIR'])
+  $bindir  = destdir + $bindir
+  $sitedir = destdir + $sitedir
+  
+  File::makedirs($bindir)
+  File::makedirs($sitedir)
+end
+
+rdoc_dest = File.join($sitedir, "rdoc")
+dot_dest  = File.join($sitedir, "dot")
+rdoc_generators = File.join(rdoc_dest, "generators")
+rdoc_templates  = File.join(rdoc_generators, "template")
+rdoc_parsers    = File.join(rdoc_dest, "parsers")
+
+File::makedirs(rdoc_dest,
+               dot_dest, 
+               rdoc_generators, 
+               rdoc_templates, 
+               rdoc_parsers,
+               true)
+
+File::chmod(0755, rdoc_dest)
+
+# The library files
+files = %w{
+ rdoc/code_objects.rb
+ rdoc/generators/*_generator.rb
+ rdoc/options.rb
+ rdoc/parsers/parserfactory.rb  
+ rdoc/parsers/parse_*.rb  
+ rdoc/template.rb
+ rdoc/tokenstream.rb
+ rdoc/diagram.rb
+ rdoc/rdoc.rb
+ dot/dot.rb
+}.collect {|f| Dir.glob(f)}.flatten
+
+for template in ["chm", "html", "xml"]
+  File::makedirs(File.join(rdoc_templates, template), true)
+  files.concat Dir.glob("rdoc/generators/template/#{template}/*.rb")
+end
+
+for aFile in files
+  File::install(aFile, File.join($sitedir, aFile), 0644, true)
+end
+
+# and the executable
+
+installBIN("rdoc.rb", "rdoc")
+
+# Temporary - we used to install html_generator in the rdoc
+# directory, but now it's moved
+
+File.unlink(File.join(rdoc_dest, "html_generator.rb")) rescue 1;
+
+# and we used to have the templates under html_template
+template = File.join(rdoc_dest, "generators", "html_template")
+File.unlink(File.join(template, "standard.rb")) rescue 1;
+File.unlink(File.join(template, "kilmer.rb")) rescue 1;
+
+# and then they were in template/ ...
+template = File.join(rdoc_dest, "generators", "template")
+File.unlink(File.join(template, "standard.rb")) rescue 1;
+File.unlink(File.join(template, "kilmer.rb")) rescue 1;
+File.unlink(File.join(template, "xml.rb")) rescue 1;
+File.unlink(File.join(template, "rdf.rb")) rescue 1;
+
+
+# 'Markup' will eventually be a separate package, but
+# for now we'll install it automatically 
+
+Dir.chdir("markup") && system("#$ruby install.rb")

data/tools/rdoc/markup/install.rb

@@ -0,0 +1,43 @@
+require 'rbconfig'
+require 'find'
+require 'ftools'
+
+include Config
+
+sitedir = CONFIG["rubylibdir"]
+unless sitedir
+  version = CONFIG["MAJOR"]+"."+CONFIG["MINOR"]
+  libdir = File.join(CONFIG["libdir"], "ruby", version)
+  sitedir = $:.find {|x| x =~ /site_ruby/}
+  if !sitedir
+    sitedir = File.join(libdir, "site_ruby")
+  elsif sitedir !~ Regexp.quote(version)
+    sitedir = File.join(sitedir, version)
+  end
+end
+
+if (destdir = ENV['DESTDIR'])
+  sitedir = destdir + sitedir
+  File::makedirs(sitedir)
+end
+
+if !File.directory?(sitedir)
+  $stderr.puts "Cannot find sitedir #{sitedir}"
+  exit 1
+end
+
+dest = File.join(sitedir, "markup")
+
+File.mkpath(dest, true)
+
+Find.find("simple_markup.rb", "simple_markup") do |fname|
+  if File.directory?(fname)
+    next if fname =~ /CVS/
+    File.mkpath(File.join(dest, fname), true)
+  else
+    next unless fname =~ /\.rb$/
+    next if fname =~ /install.rb$/
+    File.install(fname, File.join(dest, fname), 0444, true)
+  end
+end
+

data/tools/rdoc/markup/sample/sample.rb

@@ -0,0 +1,42 @@
+# This program illustrates the basic use of the SimpleMarkup
+# class. It extracts the first comment block from the 
+# simple_markup.rb file and converts it into HTML on
+# standard output. Run it using
+#
+#  % ruby sample.rb
+#
+# You should be in the sample/ directory when you do this,
+# as it hardwires the path to the files it needs to require.
+# This isn't necessary in the code you write once you've 
+# installed the package.
+#
+# For a better way of formatting code comment blocks (and more)
+# see the rdoc package.
+#
+
+$:.unshift "../.."
+
+require 'markup/simple_markup'
+require 'markup/simple_markup/to_html'
+
+# Extract the comment block from the source file
+
+input_string = ""
+
+File.foreach("../simple_markup.rb") do |line|
+  break unless line.gsub!(/^\# ?/, '')
+  input_string << line
+end
+
+# Create a markup object
+markup = SM::SimpleMarkup.new
+
+# Attach it to an HTML formatter
+h = SM::ToHtml.new
+
+# And convert out comment block to html. Wrap it a body
+# tag pair to let browsers view it
+
+puts "<html><body>"
+puts markup.convert(input_string, h)
+puts "</body></html>"

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

@@ -0,0 +1,323 @@
+require 'markup/simple_markup/lines.rb'
+require 'markup/simple_markup/inline.rb'
+
+module SM
+
+  ##
+  # 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
+
+    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
+
+    ######
+    # This is a simple factory system that lets us associate fragement
+    # types (a string) with a subclass of fragment
+
+    TYPE_MAP = {}
+
+    def Fragment.type_name(name)
+      TYPE_MAP[name] = self
+    end
+
+    def Fragment.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
+  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 Line::PARAGRAPH
+  end
+
+  class BlankLine < Paragraph
+    type_name Line::BLANK
+  end
+
+  class Heading < Paragraph
+    type_name Line::HEADING
+
+    def head_level
+      @param.to_i
+    end
+  end
+
+  ##
+  # A List is a fragment with some kind of label
+  #
+
+  class ListBase < Paragraph
+    # List types
+    BULLET  = :BULLET
+    NUMBER  = :NUMBER
+    LABELED = :LABELED
+    NOTE    = :NOTE
+  end
+
+  class ListItem < ListBase
+    type_name Line::LIST
+
+    #  def label
+    #    am = AttributeManager.new(@param)
+    #    am.flow
+    #  end
+  end
+
+  class ListStart < ListBase
+    def initialize(level, param, type)
+      super(level, param, type, nil)
+    end
+  end
+
+  class ListEnd < ListBase
+    def initialize(level, type)
+      super(level, "", type, nil)
+    end
+  end
+
+  ##
+  # Verbatim code contains lines that don't get wrapped.
+
+  class Verbatim < Fragment
+    type_name  Line::VERBATIM
+
+    def add_text(txt)
+      @txt << txt.chomp << "\n"
+    end
+
+  end
+
+  ##
+  # A horizontal rule
+  class Rule < Fragment
+    type_name Line::RULE
+  end
+
+
+  # Collect groups of lines together. Each group
+  # will end up containing a flow of text
+
+  class LineCollection
+    
+    def initialize
+      @fragments = []
+    end
+
+    def add(fragment)
+      @fragments << fragment
+    end
+
+    def each(&b)
+      @fragments.each(&b)
+    end
+
+    # For testing
+    def to_a
+      @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
+      @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
+      last_was_verbatim = false
+      @fragments.size.times do  |i|
+        if BlankLine === @fragments[i]
+          if  last_was_verbatim and
+              i < @fragments.size - 1 and
+              Verbatim === @fragments[i+1]
+            merge_fragments(i-1)
+            @fragments[i] = @fragments[i+1] = nil
+          end
+        end
+        last_was_verbatim = Verbatim === @fragments[i]
+      end
+      @fragments.compact!
+    end
+
+    # Merge the sequence Verbatim/Blank/Verbatim into
+    # a single Verbatim fragment
+    def merge_fragments(start)
+      target = @fragments[start]
+      target.add_text("\n")
+      target.add_text(@fragments[start+2].txt)
+    end
+
+    # List nesting is implicit given the level of
+    # 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
+
+    # now insert 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
+
+    # Finally 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 @fragments[i].kind_of?(BlankLine) and 
+            @fragments[i+1].kind_of?(ListEnd)
+          @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