+<% if sections["seccomment"] then %>
+
+<% end %>
+<% end %>
+
+<% if values["classlist"] then %>
+
+<% end %>
+<% end # values["sections"] %>
+ EOF
+
+#####################################################################
+### B O D Y T E M P L A T E
+#####################################################################
+
+ BODY = HEADER + %{
+
+<%= template_include %>
+
+
+
+} + FOOTER
+
+#####################################################################
+### S O U R C E C O D E T E M P L A T E
+#####################################################################
+
+ SRC_PAGE = XHTML_PREAMBLE + <<-EOF
+
+
+
+
+
+ EOF
+
+
+#####################################################################
+### I N D E X F I L E T E M P L A T E S
+#####################################################################
+
+ FR_INDEX_BODY = %{
+<%= template_include %>
+}
+
+ FILE_INDEX = XHTML_PREAMBLE + <<-EOF
+
+
+
+
+
+
+ EOF
+
+ CLASS_INDEX = FILE_INDEX
+ METHOD_INDEX = FILE_INDEX
+
+ INDEX = <<-EOF
+"?>
+
+
+
+
+
+
+
+ EOF
+
+end
+
diff -Nur --exclude=doc ruby-1.9.0/lib/rdoc/generator/xhtml.rb ../rdoc-f95-20080309/generator/xhtml.rb
--- ruby-1.9.0/lib/rdoc/generator/xhtml.rb 1970-01-01 09:00:00.000000000 +0900
+++ ../rdoc-f95-20080309/generator/xhtml.rb 2008-03-09 03:43:57.000000000 +0900
@@ -0,0 +1,106 @@
+require 'fileutils'
+
+require 'rdoc/generator'
+require 'rdoc/generator/html'
+require 'rdoc/markup/to_html'
+
+##
+# We're responsible for generating all the HTML files from the object tree
+# defined in code_objects.rb. We generate:
+#
+# [files] an html file for each input file given. These
+# input files appear as objects of class
+# TopLevel
+#
+# [classes] an html file for each class or module encountered.
+# These classes are not grouped by file: if a file
+# contains four classes, we'll generate an html
+# file for the file itself, and four html files
+# for the individual classes.
+#
+# [indices] we generate three indices for files, classes,
+# and methods. These are displayed in a browser
+# like window with three index panes across the
+# top and the selected description below
+#
+# Method descriptions appear in whatever entity (file, class, or module) that
+# contains them.
+#
+# We generate files in a structure below a specified subdirectory, normally
+# +doc+.
+#
+# opdir
+# |
+# |___ files
+# | |__ per file summaries
+# |
+# |___ classes
+# |__ per class/module descriptions
+#
+# HTML is generated using the Template class.
+
+class RDoc::Generator::XHTML < RDoc::Generator::HTML
+
+ def gen_an_index(collection, title, template, filename)
+ template = RDoc::TemplatePage.new @template::FR_INDEX_BODY, template
+ res = []
+ collection.sort.each do |f|
+ if f.document_self
+ res << { "href" => f.path, "name" => f.index_name }
+ end
+ end
+
+ values = {
+ "entries" => res,
+ 'list_title' => CGI.escapeHTML(title),
+ 'index_url' => main_url,
+ 'charset' => @options.charset,
+ 'style_url' => style_url('', @options.css),
+ 'mathml_xsl_url' => style_url('', "mathml.xsl"),
+ }
+
+ open filename, 'w' do |f|
+ template.write_html_on(f, values)
+ end
+ end
+
+ ##
+ # Build the initial indices and output objects
+ # based on an array of TopLevel objects containing
+ # the extracted information.
+
+ def generate(*args)
+ super(*args)
+
+ copy_xsls
+ end
+
+ def copy_xsls
+ xsl_files = ["mathml.xsl", "pmathmlcss.xsl", "ctop.xsl", "pmathml.xsl"]
+ xsl_dir = "rdoc/generator/xhtml"
+ hit = 0
+ $LOAD_PATH.each{ |path|
+ hit = 0
+ xsl_files.each{ |file|
+ hit += 1 if ::File.exist?(::File.join(path, xsl_dir, file))
+ }
+ if hit >= 4
+ xsl_files.each{ |file|
+ ::FileUtils.copy(::File.join(path, xsl_dir, file), "./")
+ }
+ break
+ else
+ hit = 0
+ end
+ }
+ if hit < 4
+ $stderr.puts "Couldn't find xsl files (#{xsl_files.join(', ')})\n"
+ exit
+ end
+ end
+
+end
+
+class RDoc::Generator::XHTMLInOne < RDoc::Generator::HTMLInOne
+
+end
diff -Nur --exclude=doc ruby-1.9.0/lib/rdoc/generator/xml/rdf.rb ../rdoc-f95-20080309/generator/xml/rdf.rb
--- ruby-1.9.0/lib/rdoc/generator/xml/rdf.rb 1970-01-01 09:00:00.000000000 +0900
+++ ../rdoc-f95-20080309/generator/xml/rdf.rb 2008-03-08 21:23:18.000000000 +0900
@@ -0,0 +1,113 @@
+require 'rdoc/generator/xml'
+
+module RDoc::Generator::XML::RDF
+
+ CONTENTS_RDF = <<-EOF
+<% if defined? classes and classes["description"] then %>
+
+<% end %>
+
+<% if defined? files and files["requires"] then %>
+<% files["requires"].each do |requires| %>
+
" />
+<% end # files["requires"] %>
+<% end %>
+
+<% if defined? classes and classes["includes"] then %>
+
+<% classes["includes"].each do |includes| %>
+ " />
+<% end # includes["includes"] %>
+
+<% end %>
+
+<% if defined? classes and classes["sections"] then %>
+<% classes["sections"].each do |sections| %>
+<% if sections["attributes"] then %>
+<% sections["attributes"].each do |attributes| %>
+
+ ">
+<% if attributes["rw"] then %>
+ <%= attributes["rw"] %>
+<% end %>
+ <%= attributes["a_desc"] %>
+
+
+<% end # sections["attributes"] %>
+<% end %>
+
+<% if sections["method_list"] then %>
+<% sections["method_list"].each do |method_list| %>
+<% if method_list["methods"] then %>
+<% method_list["methods"].each do |methods| %>
+
+ " rd:visibility="<%= methods["type"] %>"
+ rd:category="<%= methods["category"] %>" rd:id="<%= methods["aref"] %>">
+ <%= methods["params"] %>
+<% if methods["m_desc"] then %>
+
+<%= methods["m_desc"] %>
+
+<% end %>
+<% if methods["sourcecode"] then %>
+
+<%= methods["sourcecode"] %>
+
+<% end %>
+
+
+<% end # method_list["methods"] %>
+<% end %>
+<% end # sections["method_list"] %>
+<% end %>
+
+<% end # classes["sections"] %>
+<% end %>
+ EOF
+
+########################################################################
+
+ ONE_PAGE = %{
+
+
+
+<% values["files"].each do |files| %>
+ " rd:id="<%= files["href"] %>">
+ <%= files["full_path"] %>
+ <%= files["dtm_modified"] %>
+} + CONTENTS_RDF + %{
+
+<% end # values["files"] %>
+<% values["classes"].each do |classes| %>
+ <<%= values["classmod"] %> rd:name="<%= classes["full_name"] %>" rd:id="<%= classes["full_name"] %>">
+
+<% if classes["infiles"] then %>
+
+<% classes["infiles"].each do |infiles| %>
+
+ "
+<% if infiles["full_path_url"] then %>
+ rdf:about="<%= infiles["full_path_url"] %>"
+<% end %>
+ />
+
+<% end # classes["infiles"] %>
+
+<% end %>
+<% if classes["parent"] then %>
+ <%= href classes["par_url"], classes["parent"] %>
+<% end %>
+
+} + CONTENTS_RDF + %{
+ >
+<% end # values["classes"] %>
+
+
+}
+
+end
+
diff -Nur --exclude=doc ruby-1.9.0/lib/rdoc/generator/xml/xml.rb ../rdoc-f95-20080309/generator/xml/xml.rb
--- ruby-1.9.0/lib/rdoc/generator/xml/xml.rb 1970-01-01 09:00:00.000000000 +0900
+++ ../rdoc-f95-20080309/generator/xml/xml.rb 2008-03-08 21:23:18.000000000 +0900
@@ -0,0 +1,111 @@
+require 'rdoc/generator/xml'
+
+module RDoc::Generator::XML::XML
+
+ CONTENTS_XML = <<-EOF
+<% if defined? classes and classes["description"] then %>
+
+<%= classes["description"] %>
+
+<% end %>
+
+<% if defined? files and files["requires"] then %>
+
+<% files["requires"].each do |requires| %>
+ "
+<% if requires["aref"] then %>
+ href="<%= requires["aref"] %>"
+<% end %>
+ />
+<% end # files["requires"] %>
+
+<% end %>
+<% if defined? classes and classes["sections"] then %>
+<% classes["sections"].each do |sections| %>
+<% if sections["attributes"] then %>
+
+<% sections["attributes"].each do |attributes| %>
+ ">
+<% if attributes["rw"] then %>
+ <%= attributes["rw"] %>
+<% end %>
+ <%= attributes["a_desc"] %>
+
+<% end # sections["attributes"] %>
+
+<% end %>
+<% if sections["method_list"] then %>
+
+<% sections["method_list"].each do |method_list| %>
+<% if method_list["methods"] then %>
+<% method_list["methods"].each do |methods| %>
+ " type="<%= methods["type"] %>" category="<%= methods["category"] %>" id="<%= methods["aref"] %>">
+ <%= methods["params"] %>
+<% if methods["m_desc"] then %>
+
+<%= methods["m_desc"] %>
+
+<% end %>
+<% if methods["sourcecode"] then %>
+
+<%= methods["sourcecode"] %>
+
+<% end %>
+
+<% end # method_list["methods"] %>
+<% end %>
+<% end # sections["method_list"] %>
+
+<% end %>
+<% end # classes["sections"] %>
+<% end %>
+<% if defined? classes and classes["includes"] then %>
+
+<% classes["includes"].each do |includes| %>
+ "
+<% if includes["aref"] then %>
+ href="<%= includes["aref"] %>"
+<% end %>
+ />
+<% end # classes["includes"] %>
+
+<% end %>
+
+ EOF
+
+ ONE_PAGE = %{
+
+
+<% values["files"].each do |files| %>
+ " id="<%= files["href"] %>">
+
+ <%= files["full_path"] %>
+ <%= files["dtm_modified"] %>
+
+} + CONTENTS_XML + %{
+
+<% end # values["files"] %>
+
+
+<% values["classes"].each do |classes| %>
+ <<%= classes["classmod"] %> name="<%= classes["full_name"] %>" id="<%= classes["full_name"] %>">
+
+<% if classes["infiles"] then %>
+
+<% classes["infiles"].each do |infiles| %>
+ <%= href infiles["full_path_url"], infiles["full_path"] %>
+<% end # classes["infiles"] %>
+
+<% end %>
+<% if classes["parent"] then %>
+ <%= href classes["par_url"], classes["parent"] %>
+<% end %>
+
+} + CONTENTS_XML + %{
+ >
+<% end # values["classes"] %>
+
+
+}
+
+end
diff -Nur --exclude=doc ruby-1.9.0/lib/rdoc/generator/xml.rb ../rdoc-f95-20080309/generator/xml.rb
--- ruby-1.9.0/lib/rdoc/generator/xml.rb 1970-01-01 09:00:00.000000000 +0900
+++ ../rdoc-f95-20080309/generator/xml.rb 2008-03-08 21:21:34.000000000 +0900
@@ -0,0 +1,120 @@
+require 'rdoc/generator/html'
+
+##
+# Generate XML output as one big file
+
+class RDoc::Generator::XML < RDoc::Generator::HTML
+
+ ##
+ # Standard generator factory
+
+ def self.for(options)
+ new(options)
+ end
+
+ def initialize(*args)
+ super
+ end
+
+ ##
+ # Build the initial indices and output objects
+ # based on an array of TopLevel objects containing
+ # the extracted information.
+
+ def generate(info)
+ @info = info
+ @files = []
+ @classes = []
+ @hyperlinks = {}
+
+ build_indices
+ generate_xml
+ end
+
+ ##
+ # Generate:
+ #
+ # * a list of HtmlFile objects for each TopLevel object.
+ # * a list of HtmlClass objects for each first level
+ # class or module in the TopLevel objects
+ # * a complete list of all hyperlinkable terms (file,
+ # class, module, and method names)
+
+ def build_indices
+ @info.each do |toplevel|
+ @files << RDoc::Generator::HtmlFile.new(toplevel, @options, RDoc::Generator::FILE_DIR)
+ end
+
+ RDoc::TopLevel.all_classes_and_modules.each do |cls|
+ build_class_list(cls, @files[0], RDoc::Generator::CLASS_DIR)
+ end
+ end
+
+ def build_class_list(from, html_file, class_dir)
+ @classes << RDoc::Generator::HtmlClass.new(from, html_file, class_dir, @options)
+ from.each_classmodule do |mod|
+ build_class_list(mod, html_file, class_dir)
+ end
+ end
+
+ ##
+ # Generate all the HTML. For the one-file case, we generate
+ # all the information in to one big hash
+
+ def generate_xml
+ values = {
+ 'charset' => @options.charset,
+ 'files' => gen_into(@files),
+ 'classes' => gen_into(@classes)
+ }
+
+ # this method is defined in the template file
+ write_extra_pages if defined? write_extra_pages
+
+ template = RDoc::TemplatePage.new @template::ONE_PAGE
+
+ if @options.op_name
+ opfile = File.open(@options.op_name, "w")
+ else
+ opfile = $stdout
+ end
+ template.write_html_on(opfile, values)
+ end
+
+ def gen_into(list)
+ res = []
+ list.each do |item|
+ res << item.value_hash
+ end
+ res
+ end
+
+ def gen_file_index
+ gen_an_index(@files, 'Files')
+ end
+
+ def gen_class_index
+ gen_an_index(@classes, 'Classes')
+ end
+
+ def gen_method_index
+ gen_an_index(RDoc::Generator::HtmlMethod.all_methods, 'Methods')
+ end
+
+ def gen_an_index(collection, title)
+ res = []
+ collection.sort.each do |f|
+ if f.document_self
+ res << { "href" => f.path, "name" => f.index_name }
+ end
+ end
+
+ return {
+ "entries" => res,
+ 'list_title' => title,
+ 'index_url' => main_url,
+ }
+ end
+
+end
+
diff -Nur --exclude=doc ruby-1.9.0/lib/rdoc/generator.rb ../rdoc-f95-20080309/generator.rb
--- ruby-1.9.0/lib/rdoc/generator.rb 1970-01-01 09:00:00.000000000 +0900
+++ ../rdoc-f95-20080309/generator.rb 2008-03-09 07:52:46.000000000 +0900
@@ -0,0 +1,1088 @@
+require 'cgi'
+require 'rdoc/options'
+require 'rdoc/markup/to_html_crossref'
+require 'rdoc/markup/to_xhtml_texparser'
+require 'rdoc/template'
+
+module RDoc::Generator
+
+ ##
+ # Name of sub-direcory that holds file descriptions
+
+ FILE_DIR = "files"
+
+ ##
+ # Name of sub-direcory that holds class descriptions
+
+ CLASS_DIR = "classes"
+
+ ##
+ # Name of the RDoc CSS file
+
+ CSS_NAME = "rdoc-style.css"
+
+ ##
+ # Converts a target url to one that is relative to a given path
+
+ def self.gen_url(path, target)
+ from = ::File.dirname path
+ to, to_file = ::File.split target
+
+ from = from.split "/"
+ to = to.split "/"
+
+ while from.size > 0 and to.size > 0 and from[0] == to[0] do
+ from.shift
+ to.shift
+ end
+
+ from.delete_if{|f| f =~ /^\.$/}
+ from.fill ".."
+ from.concat to
+ from << to_file
+ ::File.join(*from)
+ end
+
+ ##
+ # Build a hash of all items that can be cross-referenced. This is used when
+ # we output required and included names: if the names appear in this hash,
+ # we can generate an html cross reference to the appropriate description.
+ # We also use this when parsing comment blocks: any decorated words matching
+ # an entry in this list are hyperlinked.
+
+ class AllReferences
+ @@refs = {}
+
+ def AllReferences::reset
+ @@refs = {}
+ end
+
+ def AllReferences.add(name, html_class)
+ @@refs[name] = html_class
+ end
+
+ def AllReferences.[](name)
+ @@refs[name]
+ end
+
+ def AllReferences.keys
+ @@refs.keys
+ end
+ end
+
+ ##
+ # Handle common markup tasks for the various Context subclasses
+
+ module MarkUp
+
+ ##
+ # Convert a string in markup format into HTML.
+
+ def markup(str, remove_para = false)
+ return '' unless str
+
+ unless defined? @formatter then
+ unless @options.mathml
+ @formatter = RDoc::Markup::ToHtmlCrossref.new(path, self,
+ @options.show_hash)
+ else
+ @formatter = RDoc::Markup::ToXHtmlTexParser.new(path, self,
+ @options.show_hash,
+ @options.mathml)
+ end
+ end
+
+ # Convert leading comment markers to spaces, but only if all non-blank
+ # lines have them
+ if str =~ /^(?>\s*)[^\#]/ then
+ content = str
+ else
+ content = str.gsub(/^\s*(#+)/) { $1.tr '#', ' ' }
+ end
+
+ unless @options.mathml
+ res = @formatter.convert content
+ else
+ res = @formatter.convert content, @formatter.block_exceptions
+ end
+
+ if remove_para then
+ res.sub!(/^/, '')
+ res.sub!(/<\/p>$/, '')
+ end
+
+ res
+ end
+
+ ##
+ # Qualify a stylesheet URL; if if +css_name+ does not begin with '/' or
+ # 'http[s]://', prepend a prefix relative to +path+. Otherwise, return it
+ # unmodified.
+
+ def style_url(path, css_name=nil)
+# $stderr.puts "style_url( #{path.inspect}, #{css_name.inspect} )"
+ css_name ||= CSS_NAME
+ if %r{^(https?:/)?/} =~ css_name
+ css_name
+ else
+ RDoc::Generator.gen_url path, css_name
+ end
+ end
+
+ ##
+ # Build a webcvs URL with the given 'url' argument. URLs with a '%s' in them
+ # get the file's path sprintfed into them; otherwise they're just catenated
+ # together.
+
+ def cvs_url(url, full_path)
+ if /%s/ =~ url
+ return sprintf( url, full_path )
+ else
+ return url + full_path
+ end
+ end
+
+ end
+
+ ##
+ # A Context is built by the parser to represent a container: contexts hold
+ # classes, modules, methods, require lists and include lists. ClassModule
+ # and TopLevel are the context objects we process here
+
+ class Context
+
+ include MarkUp
+
+ attr_reader :context
+
+ ##
+ # Generate:
+ #
+ # * a list of RDoc::Generator::File objects for each TopLevel object
+ # * a list of RDoc::Generator::Class objects for each first level class or
+ # module in the TopLevel objects
+ # * a complete list of all hyperlinkable terms (file, class, module, and
+ # method names)
+
+ def self.build_indicies(toplevels, options)
+ files = []
+ classes = []
+
+ toplevels.each do |toplevel|
+ files << RDoc::Generator::File.new(toplevel, options,
+ RDoc::Generator::FILE_DIR)
+ end
+
+ RDoc::TopLevel.all_classes_and_modules.each do |cls|
+ build_class_list(classes, options, cls, files[0],
+ RDoc::Generator::CLASS_DIR)
+ end
+
+ return files, classes
+ end
+
+ def self.build_class_list(classes, options, from, html_file, class_dir)
+ classes << RDoc::Generator::Class.new(from, html_file, class_dir, options)
+
+ from.each_classmodule do |mod|
+ build_class_list(classes, options, mod, html_file, class_dir)
+ end
+ end
+
+ def initialize(context, options)
+ @context = context
+ @options = options
+
+ # HACK ugly
+ @template = options.template_class
+ end
+
+ ##
+ # convenience method to build a hyperlink
+
+ def href(link, cls, name)
+ %{#{name}} #"
+ end
+
+ ##
+ # Returns a reference to outselves to be used as an href= the form depends
+ # on whether we're all in one file or in multiple files
+
+ def as_href(from_path)
+ if @options.all_one_file
+ "#" + path
+ else
+ RDoc::Generator.gen_url from_path, path
+ end
+ end
+
+ ##
+ # Create a list of Method objects for each method in the corresponding
+ # context object. If the @options.show_all variable is set (corresponding
+ # to the --all option, we include all methods, otherwise just the
+ # public ones.
+
+ def collect_methods
+ list = @context.method_list
+
+ unless @options.show_all then
+ list = list.find_all do |m|
+ m.visibility == :public or
+ m.visibility == :protected or
+ m.force_documentation
+ end
+ end
+
+ @methods = list.collect do |m|
+ RDoc::Generator::Method.new m, self, @options
+ end
+ end
+
+ ##
+ # Build a summary list of all the methods in this context
+
+ def build_method_summary_list(path_prefix="")
+ collect_methods unless @methods
+ meths = @methods.sort
+ res = []
+ meths.each do |meth|
+ res << {
+ "name" => CGI.escapeHTML(meth.name),
+ "aref" => "#{path_prefix}\##{meth.aref}"
+ }
+ end
+ res
+ end
+
+ ##
+ # Build a list of aliases for which we couldn't find a
+ # corresponding method
+
+ def build_alias_summary_list(section)
+ values = []
+ @context.aliases.each do |al|
+ next unless al.section == section
+ res = {
+ 'old_name' => al.old_name,
+ 'new_name' => al.new_name,
+ }
+ if al.comment && !al.comment.empty?
+ res['desc'] = markup(al.comment, true)
+ end
+ values << res
+ end
+ values
+ end
+
+ ##
+ # Build a list of constants
+
+ def build_constants_summary_list(section)
+ values = []
+ @context.constants.each do |co|
+ next unless co.section == section
+ res = {
+ 'name' => co.name,
+ 'value' => CGI.escapeHTML(co.value)
+ }
+ res['desc'] = markup(co.comment, true) if co.comment && !co.comment.empty?
+ values << res
+ end
+ values
+ end
+
+ def build_requires_list(context)
+ potentially_referenced_list(context.requires) {|fn| [fn + ".rb"] }
+ end
+
+ def build_include_list(context)
+ potentially_referenced_list(context.includes)
+ end
+
+ ##
+ # Build a list from an array of Context items. Look up each in the
+ # AllReferences hash: if we find a corresponding entry, we generate a
+ # hyperlink to it, otherwise just output the name. However, some names
+ # potentially need massaging. For example, you may require a Ruby file
+ # without the .rb extension, but the file names we know about may have it.
+ # To deal with this, we pass in a block which performs the massaging,
+ # returning an array of alternative names to match
+
+ def potentially_referenced_list(array)
+ res = []
+ array.each do |i|
+ ref = AllReferences[i.name]
+# if !ref
+# container = @context.parent
+# while !ref && container
+# name = container.name + "::" + i.name
+# ref = AllReferences[name]
+# container = container.parent
+# end
+# end
+
+ ref = @context.find_symbol(i.name, nil, @options.ignore_case) || \
+ @context.find_file(i.name)
+ ref = ref.viewer if ref
+
+ if !ref && block_given?
+ possibles = yield(i.name)
+ while !ref and !possibles.empty?
+ ref = AllReferences[possibles.shift]
+ end
+ end
+ h_name = CGI.escapeHTML(i.name)
+ if ref and ref.document_self
+ path = url(ref.path)
+ res << { "name" => h_name, "aref" => path }
+ else
+ res << { "name" => h_name }
+ end
+ end
+ res
+ end
+
+ ##
+ # Build an array of arrays of method details. The outer array has up
+ # to six entries, public, private, and protected for both class
+ # methods, the other for instance methods. The inner arrays contain
+ # a hash for each method
+
+ def build_method_detail_list(section)
+ outer = []
+
+ methods = @methods.sort
+ for singleton in [true, false]
+ for vis in [ :public, :protected, :private ]
+ res = []
+ methods.each do |m|
+ if m.section == section and
+ m.document_self and
+ m.visibility == vis and
+ m.singleton == singleton
+ row = {}
+ if m.call_seq
+ row["callseq"] = m.call_seq.gsub(/->/, '→')
+ else
+ row["name"] = CGI.escapeHTML(m.name)
+ row["params"] = m.params
+ end
+ desc = m.description.strip
+ row["m_desc"] = desc unless desc.empty?
+ row["aref"] = m.aref
+ row["visibility"] = m.visibility.to_s
+
+ alias_names = []
+ m.aliases.each do |other|
+ if other.viewer # won't be if the alias is private
+ alias_names << {
+ 'name' => other.name,
+ 'aref' => other.viewer.as_href(path)
+ }
+ end
+ end
+ unless alias_names.empty?
+ row["aka"] = alias_names
+ end
+
+ if @options.inline_source
+ code = m.source_code
+ row["sourcecode"] = code if code
+ else
+ code = m.src_url
+ if code
+ row["codeurl"] = code
+ row["imgurl"] = m.img_url
+ end
+ end
+ res << row
+ end
+ end
+ if res.size > 0
+ outer << {
+ "type" => vis.to_s.capitalize,
+ "category" => singleton ? "Class" : "Instance",
+ "methods" => res
+ }
+ end
+ end
+ end
+ outer
+ end
+
+ ##
+ # Build the structured list of classes and modules contained
+ # in this context.
+
+ def build_class_list(level, from, section, infile=nil)
+ res = ""
+ prefix = " ::" * level;
+
+ from.modules.sort.each do |mod|
+ next unless mod.section == section
+ next if infile && !mod.defined_in?(infile)
+ if mod.document_self
+ res <<
+ prefix <<
+ "Module " <<
+ href(url(mod.viewer.path), "link", mod.full_name) <<
+ "
\n" <<
+ build_class_list(level + 1, mod, section, infile)
+ end
+ end
+
+ from.classes.sort.each do |cls|
+ next unless cls.section == section
+ next if infile && !cls.defined_in?(infile)
+ if cls.document_self
+ res <<
+ prefix <<
+ "Class " <<
+ href(url(cls.viewer.path), "link", cls.full_name) <<
+ "
\n" <<
+ build_class_list(level + 1, cls, section, infile)
+ end
+ end
+
+ res
+ end
+
+ def url(target)
+ RDoc::Generator.gen_url path, target
+ end
+
+ def aref_to(target)
+ if @options.all_one_file
+ "#" + target
+ else
+ url(target)
+ end
+ end
+
+ def document_self
+ @context.document_self
+ end
+
+ def diagram_reference(diagram)
+ res = diagram.gsub(/((?:src|href)=")(.*?)"/) {
+ $1 + url($2) + '"'
+ }
+ res
+ end
+
+ ##
+ # Find a symbol in ourselves or our parent
+
+ def find_symbol(symbol, method=nil)
+ res = @context.find_symbol(symbol, method, @options.ignore_case)
+ if res
+ res = res.viewer
+ end
+ res
+ end
+
+ # Find a filenames in ourselves or our parent
+ def find_file(file, method=nil)
+ res = @context.find_file(file, method, @options.ignore_case)
+ if res
+ res = res.viewer
+ end
+ res
+ end
+
+ ##
+ # create table of contents if we contain sections
+
+ def add_table_of_sections
+ toc = []
+ @context.sections.each do |section|
+ if section.title
+ toc << {
+ 'secname' => section.title,
+ 'href' => section.sequence
+ }
+ end
+ end
+
+ @values['toc'] = toc unless toc.empty?
+ end
+
+ end
+
+ ##
+ # Wrap a ClassModule context
+
+ class Class < Context
+
+ attr_reader :methods
+ attr_reader :path
+
+ def initialize(context, html_file, prefix, options)
+ super(context, options)
+
+ @html_file = html_file
+ @is_module = context.is_module?
+ @values = {}
+
+ context.viewer = self
+
+ if options.all_one_file
+ @path = context.full_name
+ else
+ @path = http_url(context.full_name, prefix)
+ end
+
+ collect_methods
+
+ AllReferences.add(name, self)
+ end
+
+ ##
+ # Returns the relative file name to store this class in, which is also its
+ # url
+
+ def http_url(full_name, prefix)
+ path = full_name.dup
+
+ path.gsub!(/<<\s*(\w*)/, 'from-\1') if path['<<']
+ suffix = ".html"
+ suffix = ".xhtml" if @options.template == "xhtml"
+
+ ::File.join(prefix, path.split("::")) + suffix
+ end
+
+ def name
+ @context.full_name
+ end
+
+ def parent_name
+ @context.parent.full_name
+ end
+
+ def index_name
+ name
+ end
+
+ def write_on(f)
+ value_hash
+ template = RDoc::TemplatePage.new(@template::BODY,
+ @template::CLASS_PAGE,
+ @template::METHOD_LIST)
+ template.write_html_on(f, @values)
+ end
+
+ def value_hash
+ class_attribute_values
+ add_table_of_sections
+
+ @values["charset"] = @options.charset
+ @values["style_url"] = style_url(path, @options.css)
+ @values["mathml_xsl_url"] = style_url(path, "mathml.xsl")
+
+ d = markup(@context.comment)
+ @values["description"] = d unless d.empty?
+
+ ml = build_method_summary_list
+ @values["methods"] = ml unless ml.empty?
+
+ il = build_include_list(@context)
+ @values["includes"] = il unless il.empty?
+
+ @values["sections"] = @context.sections.map do |section|
+
+ secdata = {
+ "sectitle" => section.title,
+ "secsequence" => section.sequence,
+ "seccomment" => markup(section.comment)
+ }
+
+ al = build_alias_summary_list(section)
+ secdata["aliases"] = al unless al.empty?
+
+ co = build_constants_summary_list(section)
+ secdata["constants"] = co unless co.empty?
+
+ al = build_attribute_list(section)
+ secdata["attributes"] = al unless al.empty?
+
+ cl = build_class_list(0, @context, section)
+ secdata["classlist"] = cl unless cl.empty?
+
+ mdl = build_method_detail_list(section)
+ secdata["method_list"] = mdl unless mdl.empty?
+
+ secdata
+ end
+
+ @values
+ end
+
+ def build_attribute_list(section)
+ atts = @context.attributes.sort
+ res = []
+ atts.each do |att|
+ next unless att.section == section
+ if att.visibility == :public || att.visibility == :protected || @options.show_all
+ entry = {
+ "name" => CGI.escapeHTML(att.name),
+ "rw" => att.rw,
+ "a_desc" => markup(att.comment, true)
+ }
+ unless att.visibility == :public || att.visibility == :protected
+ entry["rw"] << "-"
+ end
+ res << entry
+ end
+ end
+ res
+ end
+
+ def class_attribute_values
+ h_name = CGI.escapeHTML(name)
+
+ @values["path"] = @path
+ @values["classmod"] = @is_module ? "Module" : "Class"
+ @values["title"] = "#{@values['classmod']}: #{h_name}"
+
+ c = @context
+ c = c.parent while c and !c.diagram
+ if c && c.diagram
+ @values["diagram"] = diagram_reference(c.diagram)
+ end
+
+ @values["full_name"] = h_name
+
+ parent_class = @context.superclass
+
+ if parent_class
+ @values["parent"] = CGI.escapeHTML(parent_class)
+
+ if parent_name
+ lookup = parent_name + "::" + parent_class
+ else
+ lookup = parent_class
+ end
+
+ parent_url = AllReferences[lookup] || AllReferences[parent_class]
+
+ if parent_url and parent_url.document_self
+ @values["par_url"] = aref_to(parent_url.path)
+ end
+ end
+
+ files = []
+ @context.in_files.each do |f|
+ res = {}
+ full_path = CGI.escapeHTML(f.file_absolute_name)
+
+ res["full_path"] = full_path
+ res["full_path_url"] = aref_to(f.viewer.path) if f.document_self
+
+ if @options.webcvs
+ res["cvsurl"] = cvs_url( @options.webcvs, full_path )
+ end
+
+ files << res
+ end
+
+ @values['infiles'] = files
+ end
+
+ def <=>(other)
+ self.name <=> other.name
+ end
+
+ end
+
+ ##
+ # Handles the mapping of a file's information to HTML. In reality, a file
+ # corresponds to a +TopLevel+ object, containing modules, classes, and
+ # top-level methods. In theory it _could_ contain attributes and aliases,
+ # but we ignore these for now.
+
+ class File < Context
+
+ attr_reader :path
+ attr_reader :name
+
+ def initialize(context, options, file_dir)
+ super(context, options)
+
+ @values = {}
+
+ if options.all_one_file
+ @path = filename_to_label
+ else
+ @path = http_url(file_dir)
+ end
+
+ @name = @context.file_relative_name
+
+ collect_methods
+ AllReferences.add(name, self)
+ context.viewer = self
+ end
+
+ def http_url(file_dir)
+ suffix = ".html"
+ suffix = ".xhtml" if @options.template == "xhtml"
+
+ ::File.join file_dir, "#{@context.file_relative_name.tr '.', '_'}" + suffix
+ end
+
+ def filename_to_label
+ @context.file_relative_name.gsub(/%|\/|\?|\#/) do
+ '%%%x' % $&[0].unpack('C')
+ end
+ end
+
+ def index_name
+ name
+ end
+
+ def parent_name
+ nil
+ end
+
+ def value_hash
+ file_attribute_values
+ add_table_of_sections
+
+ @values["charset"] = @options.charset
+ @values["href"] = path
+ @values["style_url"] = style_url(path, @options.css)
+ @values["mathml_xsl_url"] = style_url(path, "mathml.xsl")
+
+ if @context.comment
+ d = markup(@context.comment)
+ @values["description"] = d if d.size > 0
+ end
+
+ ml = build_method_summary_list
+ @values["methods"] = ml unless ml.empty?
+
+ il = build_include_list(@context)
+ @values["includes"] = il unless il.empty?
+
+ rl = build_requires_list(@context)
+ @values["requires"] = rl unless rl.empty?
+
+ if @options.promiscuous
+ file_context = nil
+ else
+ file_context = @context
+ end
+
+
+ @values["sections"] = @context.sections.map do |section|
+
+ secdata = {
+ "sectitle" => section.title,
+ "secsequence" => section.sequence,
+ "seccomment" => markup(section.comment)
+ }
+
+ cl = build_class_list(0, @context, section, file_context)
+ @values["classlist"] = cl unless cl.empty?
+
+ mdl = build_method_detail_list(section)
+ secdata["method_list"] = mdl unless mdl.empty?
+
+ al = build_alias_summary_list(section)
+ secdata["aliases"] = al unless al.empty?
+
+ co = build_constants_summary_list(section)
+ @values["constants"] = co unless co.empty?
+
+ secdata
+ end
+
+ @values
+ end
+
+ def write_on(f)
+ value_hash
+
+ template = RDoc::TemplatePage.new(@template::BODY,
+ @template::FILE_PAGE,
+ @template::METHOD_LIST)
+
+ template.write_html_on(f, @values)
+ end
+
+ def file_attribute_values
+ full_path = @context.file_absolute_name
+ short_name = ::File.basename full_path
+
+ @values["title"] = CGI.escapeHTML("File: #{short_name}")
+
+ if @context.diagram then
+ @values["diagram"] = diagram_reference(@context.diagram)
+ end
+
+ @values["short_name"] = CGI.escapeHTML(short_name)
+ @values["full_path"] = CGI.escapeHTML(full_path)
+ @values["dtm_modified"] = @context.file_stat.mtime.to_s
+
+ if @options.webcvs then
+ @values["cvsurl"] = cvs_url @options.webcvs, @values["full_path"]
+ end
+ end
+
+ def <=>(other)
+ self.name <=> other.name
+ end
+
+ end
+
+ class Method
+
+ include MarkUp
+
+ attr_reader :context
+ attr_reader :src_url
+ attr_reader :img_url
+ attr_reader :source_code
+
+ @@seq = "M000000"
+
+ @@all_methods = []
+
+ def self.all_methods
+ @@all_methods
+ end
+
+ def self.reset
+ @@all_methods = []
+ end
+
+ def initialize(context, html_class, options)
+ @context = context
+ @html_class = html_class
+ @options = options
+
+ # HACK ugly
+ @template = options.template_class
+
+ @@seq = @@seq.succ
+ @seq = @@seq
+ @@all_methods << self
+
+ context.viewer = self
+
+ if (ts = @context.token_stream)
+ @source_code = markup_code(ts)
+ unless @options.inline_source
+ @src_url = create_source_code_file(@source_code)
+ @img_url = RDoc::Generator.gen_url path, 'source.png'
+ end
+ end
+
+ AllReferences.add(name, self)
+ end
+
+ ##
+ # Returns a reference to outselves to be used as an href= the form depends
+ # on whether we're all in one file or in multiple files
+
+ def as_href(from_path)
+ if @options.all_one_file
+ "#" + path
+ else
+ RDoc::Generator.gen_url from_path, path
+ end
+ end
+
+ def name
+ @context.name
+ end
+
+ def section
+ @context.section
+ end
+
+ def index_name
+ "#{@context.name} (#{@html_class.name})"
+ end
+
+ def parent_name
+ if @context.parent.parent
+ @context.parent.parent.full_name
+ else
+ nil
+ end
+ end
+
+ def aref
+ @seq
+ end
+
+ def path
+ if @options.all_one_file
+ aref
+ else
+ @html_class.path + "#" + aref
+ end
+ end
+
+ def description
+ markup(@context.comment)
+ end
+
+ def visibility
+ @context.visibility
+ end
+
+ def singleton
+ @context.singleton
+ end
+
+ def call_seq
+ cs = @context.call_seq
+ if cs
+ cs.gsub(/\n/, "
\n")
+ else
+ nil
+ end
+ end
+
+ def params
+ # params coming from a call-seq in 'C' will start with the
+ # method name
+ if p !~ /^\w/
+ p = @context.params.gsub(/\s*\#.*/, '')
+ p = p.tr("\n", " ").squeeze(" ")
+ p = "(" + p + ")" unless p[0] == ?( || p == ''
+
+ if (block = @context.block_params)
+ # If this method has explicit block parameters, remove any
+ # explicit &block
+
+ p.sub!(/,?\s*&\w+/, '')
+
+ block.gsub!(/\s*\#.*/, '')
+ block = block.tr("\n", " ").squeeze(" ")
+ if block[0] == ?(
+ block.sub!(/^\(/, '').sub!(/\)/, '')
+ end
+ p << " {|#{block.strip}| ...}"
+ end
+ end
+ CGI.escapeHTML(p)
+ end
+
+ def create_source_code_file(code_body)
+ suffix = "html"
+ suffix = "xhtml" if @options.template == "xhtml"
+ template_regexp = Regexp.new("\\." + suffix + "$")
+ meth_path = @html_class.path.sub(template_regexp, '.src')
+ FileUtils.mkdir_p(meth_path)
+ file_path = ::File.join(meth_path, @seq) + '.' + suffix
+
+ template = RDoc::TemplatePage.new(@template::SRC_PAGE)
+
+ open file_path, 'w' do |f|
+ values = {
+ 'title' => CGI.escapeHTML(index_name),
+ 'code' => code_body,
+ 'style_url' => style_url(file_path, @options.css),
+ 'mathml_xsl_url' => style_url(file_path, "mathml.xsl"),
+ 'charset' => @options.charset
+ }
+ template.write_html_on(f, values)
+ end
+
+ RDoc::Generator.gen_url path, file_path
+ end
+
+ def <=>(other)
+ @context <=> other.context
+ end
+
+ ##
+ # Given a sequence of source tokens, mark up the source code
+ # to make it look purty.
+
+ def markup_code(tokens)
+ src = ""
+ tokens.each do |t|
+ next unless t
+ # p t.class
+# style = STYLE_MAP[t.class]
+ style = case t
+ when RubyToken::TkCONSTANT then "ruby-constant"
+ when RubyToken::TkKW then "ruby-keyword kw"
+ when RubyToken::TkIVAR then "ruby-ivar"
+ when RubyToken::TkOp then "ruby-operator"
+ when RubyToken::TkId then "ruby-identifier"
+ when RubyToken::TkNode then "ruby-node"
+ when RubyToken::TkCOMMENT then "ruby-comment cmt"
+ when RubyToken::TkREGEXP then "ruby-regexp re"
+ when RubyToken::TkSTRING then "ruby-value str"
+ when RubyToken::TkVal then "ruby-value"
+ else
+ nil
+ end
+
+ text = CGI.escapeHTML(t.text)
+
+ if style
+ src << "#{text}"
+ else
+ src << text
+ end
+ end
+
+ add_line_numbers(src) if @options.include_line_numbers
+ src
+ end
+
+ ##
+ # We rely on the fact that the first line of a source code listing has
+ # # File xxxxx, line dddd
+
+ def add_line_numbers(src)
+ if src =~ /\A.*, line (\d+)/
+ first = $1.to_i - 1
+ last = first + src.count("\n")
+ size = last.to_s.length
+ real_fmt = "%#{size}d: "
+ fmt = " " * (size+2)
+ src.gsub!(/^/) do
+ res = sprintf(fmt, first)
+ first += 1
+ fmt = real_fmt
+ res
+ end
+ end
+ end
+
+ def document_self
+ @context.document_self
+ end
+
+ def aliases
+ @context.aliases
+ end
+
+ def find_symbol(symbol, method=nil)
+ res = @context.parent.find_symbol(symbol, method, @options.ignore_case)
+ if res
+ res = res.viewer
+ end
+ res
+ end
+
+ # Find a filenames in ourselves or our parent
+ def find_file(file, method=nil)
+ res = @context.parent.find_file(file, method, @options.ignore_case)
+ if res
+ res = res.viewer
+ end
+ res
+ end
+
+ end
+
+end
+
diff -Nur --exclude=doc ruby-1.9.0/lib/rdoc/install.rb ../rdoc-f95-20080309/install.rb
--- ruby-1.9.0/lib/rdoc/install.rb 1970-01-01 09:00:00.000000000 +0900
+++ ../rdoc-f95-20080309/install.rb 2008-03-09 03:43:55.000000000 +0900
@@ -0,0 +1,166 @@
+require 'rbconfig'
+require 'find'
+require 'fileutils'
+require 'optparse'
+
+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
+ [".", "/tmp", "c:/temp", $bindir].each{|t|
+ stat = File.stat(t) rescue next
+ if stat.directory? and stat.writable?
+ tmp_dir = t
+ break
+ 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
+ FileUtils::makedirs($bindir, {:verbose => true})
+ FileUtils::install(tmp_file, File.join($bindir, opfile),
+ {:mode => 0755, :verbose => true})
+ FileUtils::safe_unlink(tmp_file)
+end
+
+# Main Program
+
+opt = OptionParser.new
+OPTS = {}
+opt.summary_width = 23
+opt.summary_indent = ''*1
+opt.on('--bindir=VAL',
+ 'Directory to which the executable file is installed') \
+ {|v| $bindir = v.to_s}
+opt.on('--binname=VAL',
+ 'Name of the executable file (default name is "rdoc")') \
+ {|v| $binname = v.to_s}
+opt.on('--libdir=VAL',
+ 'Directory to which the libraries are installed') \
+ {|v| $libdir = v.to_s}
+opt.on('--help', 'Show help message') {|v| OPTS[:help] = v}
+
+opt.parse!(ARGV)
+
+$bindir = File.expand_path($bindir) if $bindir
+$binname ||= "rdoc"
+$libdir = File.expand_path($libdir) if $libdir
+
+install_opt = ""
+install_opt = "--libdir=#{$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
+
+$bindir ||= CONFIG["bindir"]
+$realbindir = $bindir
+
+bindir = CONFIG["bindir"]
+
+rdoc_dest = File.join($sitedir, "rdoc")
+rdoc_generator = File.join(rdoc_dest, "generator")
+rdoc_parsers = File.join(rdoc_dest, "parsers")
+rdoc_ri = File.join(rdoc_dest, "ri")
+
+# help message
+if ARGV[0] || OPTS[:help]
+ print <<-HELP
+
+ This ruby script installs libraries to \"#{$sitedir}\",
+ and executables to \"#{$bindir}/#{$binname}\". (See \"rbconfig.rb\")
+
+ If you want to install other directory, use following options.
+
+ #{opt.help}
+
+HELP
+ exit
+end
+
+# make directories
+[
+ rdoc_dest,
+ rdoc_generator,
+ rdoc_parsers,
+ rdoc_ri].each{|d|
+ FileUtils::makedirs(d, {:verbose => true})
+}
+
+FileUtils::chmod(0755, rdoc_dest)
+
+
+
+# The library files
+files = %w{
+ code_objects.rb
+ generator.rb
+ generator/*.rb
+ options.rb
+ parsers/parserfactory.rb
+ parsers/parse_*.rb
+ template.rb
+ tokenstream.rb
+ diagram.rb
+ rdoc.rb
+ dot.rb
+ ri/*.rb
+ ri.rb
+ markup.rb
+ stats.rb
+}.collect {|f| Dir.glob(f)}.flatten
+
+["chm", "html", "xml", "xhtml"].each{ |template|
+ d = File.join(rdoc_generator, template)
+ FileUtils::makedirs(d, {:verbose => true})
+ files.concat Dir.glob("generator/#{template}/*.rb")
+ files.concat Dir.glob("generator/#{template}/*.xsl")
+}
+
+files.each{ |aFile|
+ dst = File.join(rdoc_dest, aFile)
+ FileUtils::install(aFile, dst, {:mode => 0644, :verbose => true})
+}
+
+# and the executable
+
+installBIN("rdoc", $binname)
+
+# 'Markup' will eventually be a separate package, but
+# for now we'll install it automatically
+
+Dir.chdir("markup") && system("#$ruby install.rb #{install_opt}")
diff -Nur --exclude=doc ruby-1.9.0/lib/rdoc/markup/formatter.rb ../rdoc-f95-20080309/markup/formatter.rb
--- ruby-1.9.0/lib/rdoc/markup/formatter.rb 1970-01-01 09:00:00.000000000 +0900
+++ ../rdoc-f95-20080309/markup/formatter.rb 2008-03-09 06:49:08.000000000 +0900
@@ -0,0 +1,14 @@
+require 'rdoc/markup'
+
+class RDoc::Markup::Formatter
+
+ def initialize
+ @markup = RDoc::Markup.new
+ end
+
+ def convert(content, block_exceptions=nil)
+ @markup.convert content, self, block_exceptions
+ end
+
+end
+
diff -Nur --exclude=doc ruby-1.9.0/lib/rdoc/markup/fragments.rb ../rdoc-f95-20080309/markup/fragments.rb
--- ruby-1.9.0/lib/rdoc/markup/fragments.rb 1970-01-01 09:00:00.000000000 +0900
+++ ../rdoc-f95-20080309/markup/fragments.rb 2008-03-08 18:36:21.000000000 +0900
@@ -0,0 +1,337 @@
+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
+
+ class BlankLine < Paragraph
+ type_name :BLANK
+ end
+
+ class Heading < Paragraph
+ type_name :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,
+ :NUMBER,
+ :UPPERALPHA,
+ :LOWERALPHA,
+ :LABELED,
+ :NOTE,
+ ]
+ end
+
+ class ListItem < ListBase
+ type_name :LIST
+
+ def to_s
+ text = if [:NOTE, :LABELED].include? type then
+ "#{@param}: #{@txt}"
+ else
+ @txt
+ end
+
+ "L#@level: #{type} #{self.class.name.split('::')[-1]}\n#{text}"
+ 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 :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
+
+ def initialize
+ @fragments = []
+ end
+
+ def add(fragment)
+ @fragments << fragment
+ end
+
+ 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
+ @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
+
diff -Nur --exclude=doc ruby-1.9.0/lib/rdoc/markup/inline.rb ../rdoc-f95-20080309/markup/inline.rb
--- ruby-1.9.0/lib/rdoc/markup/inline.rb 1970-01-01 09:00:00.000000000 +0900
+++ ../rdoc-f95-20080309/markup/inline.rb 2008-03-08 18:36:21.000000000 +0900
@@ -0,0 +1,361 @@
+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
+
+ ##
+ # 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 inspect
+ "#" % [
+ 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
+
+ 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
+
+ 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 textto the sequence
+ # \001\002\001\003, where is a per-attribute specific
+ # character
+
+ def convert_attrs(str, attrs)
+ # first do matching ones
+ tags = MATCHING_WORD_PAIRS.keys.join("")
+
+ re = /(^|\W)([#{tags}])([#\\]?[\w.\/]+?\S?)\2(\W|$)/
+
+ 1 while str.gsub!(re) do
+ 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
+ end
+
+ # then non-matching
+ unless WORD_PAIR_MAP.empty? then
+ 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 '|'
+
+ 1 while str.gsub!(/<(#{tags})>(.*?)<\/\1>/i) {
+ 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, $&.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 = %w[<\\]
+
+ 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\000")
+ 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)
+ add_html("code", :TT)
+
+ add_special(//, :COMMENT)
+ 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
+
+ puts("Before flow, str='#{@str.dump}'") if $DEBUG_RDOC
+ mask_protected_sequences
+
+ @attrs = AttrSpan.new(@str.length)
+
+ puts("After protecting, str='#{@str.dump}'") if $DEBUG_RDOC
+
+ convert_attrs(@str, @attrs)
+ convert_html(@str, @attrs)
+ convert_specials(str, @attrs)
+
+ unmask_protected_sequences
+
+ puts("After flow, str='#{@str.dump}'") if $DEBUG_RDOC
+
+ 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_RDOC
+
+ res = []
+ current_attr = 0
+ str = ""
+
+ str_len = @str.length
+
+ # skip leading invisible text
+ i = 0
+ i += 1 while i < str_len and @str[i] == "\0"
+ 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] == "\0"
+ 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
+
diff -Nur --exclude=doc ruby-1.9.0/lib/rdoc/markup/install.rb ../rdoc-f95-20080309/markup/install.rb
--- ruby-1.9.0/lib/rdoc/markup/install.rb 1970-01-01 09:00:00.000000000 +0900
+++ ../rdoc-f95-20080309/markup/install.rb 2008-03-08 18:36:21.000000000 +0900
@@ -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
diff -Nur --exclude=doc ruby-1.9.0/lib/rdoc/markup/lines.rb ../rdoc-f95-20080309/markup/lines.rb
--- ruby-1.9.0/lib/rdoc/markup/lines.rb 1970-01-01 09:00:00.000000000 +0900
+++ ../rdoc-f95-20080309/markup/lines.rb 2008-03-08 18:36:21.000000000 +0900
@@ -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
+
diff -Nur --exclude=doc ruby-1.9.0/lib/rdoc/markup/mathml_wrapper.rb ../rdoc-f95-20080309/markup/mathml_wrapper.rb
--- ruby-1.9.0/lib/rdoc/markup/mathml_wrapper.rb 1970-01-01 09:00:00.000000000 +0900
+++ ../rdoc-f95-20080309/markup/mathml_wrapper.rb 2008-03-09 12:38:00.000000000 +0900
@@ -0,0 +1,79 @@
+# 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|
+ io.each{ |line|
+ 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"
+ 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
diff -Nur --exclude=doc ruby-1.9.0/lib/rdoc/markup/preprocess.rb ../rdoc-f95-20080309/markup/preprocess.rb
--- ruby-1.9.0/lib/rdoc/markup/preprocess.rb 1970-01-01 09:00:00.000000000 +0900
+++ ../rdoc-f95-20080309/markup/preprocess.rb 2008-03-08 18:36:21.000000000 +0900
@@ -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
+
diff -Nur --exclude=doc ruby-1.9.0/lib/rdoc/markup/sample/rdoc2latex.rb ../rdoc-f95-20080309/markup/sample/rdoc2latex.rb
--- ruby-1.9.0/lib/rdoc/markup/sample/rdoc2latex.rb 1970-01-01 09:00:00.000000000 +0900
+++ ../rdoc-f95-20080309/markup/sample/rdoc2latex.rb 2005-09-22 16:49:19.000000000 +0900
@@ -0,0 +1,16 @@
+#!/usr/local/bin/ruby
+# Illustration of a script to convert an RDoc-style file to a LaTeX
+# document
+
+require 'rdoc/markup/simple_markup'
+require 'rdoc/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}"
diff -Nur --exclude=doc ruby-1.9.0/lib/rdoc/markup/sample/sample.rb ../rdoc-f95-20080309/markup/sample/sample.rb
--- ruby-1.9.0/lib/rdoc/markup/sample/sample.rb 1970-01-01 09:00:00.000000000 +0900
+++ ../rdoc-f95-20080309/markup/sample/sample.rb 2005-09-22 16:49:19.000000000 +0900
@@ -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/markup/simple_markup'
+require 'rdoc/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 ""
+puts markup.convert(input_string, h)
+puts ""
diff -Nur --exclude=doc ruby-1.9.0/lib/rdoc/markup/to_flow.rb ../rdoc-f95-20080309/markup/to_flow.rb
--- ruby-1.9.0/lib/rdoc/markup/to_flow.rb 1970-01-01 09:00:00.000000000 +0900
+++ ../rdoc-f95-20080309/markup/to_flow.rb 2008-03-08 18:36:21.000000000 +0900
@@ -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 => [ "" ],
+ :NUMBER => [ "", "
" ],
+ :UPPERALPHA => [ "", "
" ],
+ :LOWERALPHA => [ "", "
" ],
+ :LABELED => [ "", "
" ],
+ :NOTE => [ "" ],
+ }
+
+ 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), "", ""),
+ InlineTag.new(RDoc::Markup::Attribute.bitmap_for(:TT), "", ""),
+ InlineTag.new(RDoc::Markup::Attribute.bitmap_for(: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("") << "\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
+
diff -Nur --exclude=doc ruby-1.9.0/lib/rdoc/markup/to_html.rb ../rdoc-f95-20080309/markup/to_html.rb
--- ruby-1.9.0/lib/rdoc/markup/to_html.rb 1970-01-01 09:00:00.000000000 +0900
+++ ../rdoc-f95-20080309/markup/to_html.rb 2008-03-09 03:43:59.000000000 +0900
@@ -0,0 +1,357 @@
+require 'rdoc/markup/formatter'
+require 'rdoc/markup/fragments'
+require 'rdoc/markup/inline'
+require 'rdoc/generator'
+
+require 'cgi'
+
+class RDoc::Markup::ToHtml < RDoc::Markup::Formatter
+
+ LIST_TYPE_TO_HTML = {
+ :BULLET => %w[],
+ :NUMBER => %w[
],
+ :UPPERALPHA => %w[
],
+ :LOWERALPHA => %w[
],
+ :LABELED => %w[
],
+ :NOTE => %w[],
+ }
+
+ InlineTag = Struct.new(:bit, :on, :off)
+
+ def initialize
+ super
+
+ # external hyperlinks
+ @markup.add_special(/((link:|https?:|mailto:|ftp:|www\.)\S+\w)/, :HYPERLINK)
+
+ # and links of the form []
+ @markup.add_special(/(((\{.*?\})|\b\S+?)\[\S+?\.\S+?\])/, :TIDYLINK)
+
+ init_tags
+ end
+
+ ##
+ # Generate a hyperlink for url, labeled with text. Handle the
+ # special cases for img: and link: described under handle_special_HYPEDLINK
+
+ def gen_url(url, text)
+ if url =~ /([A-Za-z]+):(.*)/ then
+ type = $1
+ path = $2
+ else
+ type = "http"
+ path = url
+ url = "http://#{url}"
+ end
+
+ if type == "link" then
+ url = if path[0, 1] == '#' then # is this meaningful?
+ path
+ else
+ RDoc::Generator.gen_url @from_path, path
+ end
+ end
+
+ if (type == "http" or type == "link") and
+ url =~ /\.(gif|png|jpg|jpeg|bmp)$/ then
+ "![](\"#{url}\")
"
+
+ elsif type == "link"
+ "#{text.sub(%r{^#{type}:/*}, '')}"
+ else
+ "#{text.sub(%r{^#{type}:/*}, '')}"
+ end
+ end
+
+ ##
+ # And we're invoked with a potential external hyperlink mailto:
+ # just gets inserted. http: links are checked to see if they
+ # reference an image. If so, that image gets inserted using an
+ # ![]()
tag. Otherwise a conventional is used. We also
+ # support a special type of hyperlink, link:, which is a reference
+ # to a local file whose path is relative to the --op directory.
+
+ def handle_special_HYPERLINK(special)
+ url = special.text
+ gen_url url, url
+ end
+
+ ##
+ # Here's a hypedlink where the label is different to the URL
+ #