rdoc-f95 0.0.1

data/lib/rdoc-f95/markup/install.rb

@@ -0,0 +1,57 @@
+require 'rbconfig'
+require 'find'
+require 'fileutils'
+require 'optparse'
+
+include Config
+
+opt = OptionParser.new
+libdir = nil
+opt.on('--libdir=VAL') {|v| libdir  = v}
+opt.parse!(ARGV)
+
+libdir = File.expand_path(libdir) if libdir
+
+if libdir
+  sitedir = libdir
+else
+  sitedir = CONFIG["sitelibdir"]
+  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
+end
+
+unless /^\// =~ sitedir.strip
+  sitedir = File.join("..", sitedir)
+end
+
+if !File.directory?(sitedir)
+  $stderr.puts "Cannot find sitedir #{sitedir}"
+  exit 1
+end
+
+rdoc_dest = File.join(sitedir, "rdoc")
+
+dest = File.join(rdoc_dest, "markup")
+
+FileUtils::makedirs(dest, {:verbose => true})
+
+Find.find("./",
+          "sample") do |fname|
+  if File.directory?(fname)
+    next if fname =~ /CVS/
+    FileUtils::makedirs(File.join(dest, fname), {:verbose => true})
+  else
+    next unless fname =~ /\.rb$/
+    next if fname =~ /install.rb$/
+    FileUtils::install(fname, File.join(dest, fname), 
+                       {:mode => 0444, :verbose => true})
+  end
+end

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

@@ -0,0 +1,152 @@
+class RDocF95::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-f95/markup/mathml_wrapper.rb

@@ -0,0 +1,91 @@
+# This class is MathML module wrapper.
+# If MathML module can not be loaded, methods in this module return
+# raw argument without modification.
+require 'fileutils'
+
+class MathMLWrapper
+
+  # Mathml library name
+  MATHML_NAME = [ "mathml", "math_ml" ]
+
+  # $LOAD_PATH/MATHML_NAME/MACRO_REL_PATH/* files are parsed as TeX macro
+  MACRO_REL_PATH = "macro"
+
+  @@mathml_required = false
+  @@macro_input_flag = false
+  @@macro_path = ''
+
+  def initialize
+
+    err_count = 0
+    if !@@mathml_required
+      MATHML_NAME.each{ |ml|
+        begin
+          require ml
+          @@macro_path = File.join(ml, MACRO_REL_PATH)
+        rescue LoadError
+          err_count = err_count + 1
+        end
+      }
+      if err_count < MATHML_NAME.size
+        @@mathml_required = true
+      else
+        raise LoadError, 
+          "  Error: \"#{MATHML_NAME.join('" or "')}\" library is not found\n" +
+          "         in $LOAD_PATH=[#{$LOAD_PATH.join(',')}]\n\n"
+      end
+    end
+
+    if (@@mathml_required && !@@macro_input_flag)
+      @@mathml_formula_macro = MathML::LaTeX::Parser.new
+      @@macro_input_flag = true
+      $LOAD_PATH.each{ |lpath|
+        macro_files = Dir::glob(File.join(lpath, @@macro_path, "*"))
+        macro_files.each{ |mfile|
+          if File.file?(mfile)
+            File.open(mfile, "r" ) { |io|
+              if $DEBUG_RDOC 
+                puts \
+                  "\n##### Debug messages about \"#{__FILE__}\" #####", 
+                  "  \"#{mfile}\" is loading as a TeX macro file.", 
+                  "  Following macros have been included."
+              end
+              io.each{ |line|
+                line.chomp!
+                macroerrormsg = nil
+                begin
+                  @@mathml_formula_macro.macro.parse(line)
+                rescue MathML::LaTeX::ParseError
+                  macroerrormsg = $!.to_s
+                rescue
+                  macroerrormsg = $!.to_s
+                end
+                if macroerrormsg
+                  $stderr.puts "Warning: in #{mfile}, following TeX macro causes #{macroerrormsg.to_s}\n\n",
+                  "    #{line}\n\n"
+                else
+                  if $DEBUG_RDOC && !(line.empty?) && !(line =~ /\s*\%/)
+                    puts "    #{line}"
+                  end
+                end
+              }
+            }
+          end
+        }
+      }
+    end
+
+  end
+  def parse(formula, block=false)
+    return formula if !@@mathml_required
+    mathml_formula = @@mathml_formula_macro
+    begin
+      mathml_formula_str = mathml_formula.parse(formula, block).to_s
+    rescue MathML::LaTeX::ParseError
+      return formula, 1
+    rescue
+      return formula, 1
+    end
+    return mathml_formula_str, 0
+  end
+end

data/lib/rdoc-f95/markup/preprocess.rb

@@ -0,0 +1,71 @@
+require 'rdoc-f95/markup'
+
+##
+# Handle common directives that can occur in a block of text:
+#
+# : include : filename
+
+class RDocF95::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-f95/markup/sample/rdoc2latex.rb

@@ -0,0 +1,16 @@
+#!/usr/local/bin/ruby
+# Illustration of a script to convert an RDoc-style file to a LaTeX
+# document
+
+require 'rdoc-f95/markup/simple_markup'
+require 'rdoc-f95/markup/simple_markup/to_latex'
+
+p = SM::SimpleMarkup.new
+h = SM::ToLaTeX.new
+
+#puts "\\documentclass{report}"
+#puts "\\usepackage{tabularx}"
+#puts "\\usepackage{parskip}"
+#puts "\\begin{document}"
+puts p.convert(ARGF.read, h)
+#puts "\\end{document}"

data/lib/rdoc-f95/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 'rdoc-f95/markup/simple_markup'
+require 'rdoc-f95/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/lib/rdoc-f95/markup/to_flow.rb

@@ -0,0 +1,185 @@
+require 'rdoc-f95/markup/formatter'
+require 'rdoc-f95/markup/fragments'
+require 'rdoc-f95/markup/inline'
+require 'cgi'
+
+class RDocF95::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 < RDocF95::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(RDocF95::Markup::Attribute.bitmap_for(:BOLD), "<b>", "</b>"),
+        InlineTag.new(RDocF95::Markup::Attribute.bitmap_for(:TT),   "<tt>", "</tt>"),
+        InlineTag.new(RDocF95::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(RDocF95::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
+