mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
Add RDoc
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@5073 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
dave
parent
c1c55573bd
commit
87762adcb0
36 changed files with 12367 additions and 0 deletions
|
|
@ -1,3 +1,7 @@
|
||||||
|
Mon Dec 1 16:10:52 2003 Dave Thomas <dave@pragprog.com>
|
||||||
|
|
||||||
|
* lib/rdoc/rdoc.rb: (etc) initial merge into main tree.
|
||||||
|
|
||||||
Mon Dec 1 14:17:49 2003 Minero Aoki <aamine@loveruby.net>
|
Mon Dec 1 14:17:49 2003 Minero Aoki <aamine@loveruby.net>
|
||||||
|
|
||||||
* lib/fileutils.rb (fu_each_src_dest0): call #to_str to allow
|
* lib/fileutils.rb (fu_each_src_dest0): call #to_str to allow
|
||||||
|
|
|
||||||
67
bin/rdoc
Normal file
67
bin/rdoc
Normal file
|
|
@ -0,0 +1,67 @@
|
||||||
|
#!/usr/bin/env ruby
|
||||||
|
#
|
||||||
|
# RDoc: Documentation tool for source code
|
||||||
|
# (see lib/rdoc/rdoc.rb for more information)
|
||||||
|
#
|
||||||
|
# Copyright (c) 2003 Dave Thomas
|
||||||
|
# Released under the same terms as Ruby
|
||||||
|
#
|
||||||
|
# $Revision$
|
||||||
|
|
||||||
|
## Transitional Hack ####
|
||||||
|
#
|
||||||
|
# RDoc was initially distributed independently, and installed
|
||||||
|
# itself into <prefix>/lib/ruby/site_ruby/<ver>/rdoc...
|
||||||
|
#
|
||||||
|
# Now that RDoc is part of the distribution, it's installed into
|
||||||
|
# <prefix>/lib/ruby/<ver>, which unfortunately appears later in the
|
||||||
|
# search path. This means that if you have previously installed RDoc,
|
||||||
|
# and then install from ruby-lang, you'll pick up the old one by
|
||||||
|
# default. This hack checks for the condition, and readjusts the
|
||||||
|
# search path if necessary.
|
||||||
|
|
||||||
|
def adjust_for_existing_rdoc(path)
|
||||||
|
|
||||||
|
$stderr.puts %{
|
||||||
|
It seems as if you have a previously-installed RDoc in
|
||||||
|
the directory #{path}.
|
||||||
|
|
||||||
|
Because this is now out-of-date, you might want to consider
|
||||||
|
removing the directories:
|
||||||
|
|
||||||
|
#{File.join(path, "rdoc")}
|
||||||
|
|
||||||
|
and
|
||||||
|
|
||||||
|
#{File.join(path, "markup")}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
# Move all the site_ruby directories to the end
|
||||||
|
p $:
|
||||||
|
$:.replace($:.partition {|path| /site_ruby/ !~ path}.flatten)
|
||||||
|
p $:
|
||||||
|
end
|
||||||
|
|
||||||
|
$:.each do |path|
|
||||||
|
if /site_ruby/ =~ path
|
||||||
|
rdoc_path = File.join(path, 'rdoc', 'rdoc.rb')
|
||||||
|
if File.exists?(rdoc_path)
|
||||||
|
adjust_for_existing_rdoc(path)
|
||||||
|
break
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
## End of Transitional Hack ##
|
||||||
|
|
||||||
|
|
||||||
|
require 'rdoc/rdoc'
|
||||||
|
|
||||||
|
begin
|
||||||
|
r = RDoc::RDoc.new
|
||||||
|
r.document(ARGV)
|
||||||
|
rescue RDoc::RDocError => e
|
||||||
|
$stderr.puts e.message
|
||||||
|
exit(1)
|
||||||
|
end
|
||||||
445
lib/rdoc/README
Normal file
445
lib/rdoc/README
Normal file
|
|
@ -0,0 +1,445 @@
|
||||||
|
= RDOC - Ruby Documentation System
|
||||||
|
|
||||||
|
This package contains Rdoc and SimpleMarkup. Rdoc is an application
|
||||||
|
that produces documentation for one or more Ruby source files. We work
|
||||||
|
similarly to JavaDoc, parsing the source, and extracting the
|
||||||
|
definition for classes, modules, and methods (along with includes and
|
||||||
|
requires). We associate with these optional documentation contained
|
||||||
|
in the immediately preceding comment block, and then render the result
|
||||||
|
using a pluggable output formatter. (Currently, HTML is the only
|
||||||
|
supported format. Markup is a library that converts plain text into
|
||||||
|
various output formats. The Markup library is used to interpret the
|
||||||
|
comment blocks that Rdoc uses to document methods, classes, and so on.
|
||||||
|
|
||||||
|
This library contains two packages, rdoc itself and a text markup
|
||||||
|
library, 'markup'.
|
||||||
|
|
||||||
|
== Roadmap
|
||||||
|
|
||||||
|
* If you want to use Rdoc to create documentation for your Ruby source
|
||||||
|
files, read on.
|
||||||
|
* If you want to include extensions written in C, see rdoc/parsers/parse_c.rb.
|
||||||
|
* For information on the various markups available in comment
|
||||||
|
blocks, see markup/simple_markup.rb.
|
||||||
|
* If you want to drive Rdoc programatically, see RDoc::RDoc.
|
||||||
|
* If you want to use the library to format text blocks into HTML,
|
||||||
|
have a look at SM::SimpleMarkup.
|
||||||
|
* If you want to try writing your own HTML output template, see
|
||||||
|
RDoc::Page.
|
||||||
|
|
||||||
|
== Summary
|
||||||
|
|
||||||
|
Once installed, you can create documentation using the 'rdoc' command
|
||||||
|
(the command is 'rdoc.bat' under Windows)
|
||||||
|
|
||||||
|
% rdoc [options] [names...]
|
||||||
|
|
||||||
|
Type "rdoc --help" for an up-to-date option summary.
|
||||||
|
|
||||||
|
A typical use might be to generate documentation for a package of Ruby
|
||||||
|
source (such as rdoc itself).
|
||||||
|
|
||||||
|
% rdoc
|
||||||
|
|
||||||
|
This command generates documentation for all the Ruby and C source
|
||||||
|
files in and below the current directory. These will be stored in a
|
||||||
|
documentation tree starting in the subdirectory 'doc'.
|
||||||
|
|
||||||
|
You can make this slightly more useful for your readers by having the
|
||||||
|
index page contain the documentation for the primary file. In our
|
||||||
|
case, we could type
|
||||||
|
|
||||||
|
% rdoc --main rdoc/rdoc.rb
|
||||||
|
|
||||||
|
You'll find information on the various formatting tricks you can use
|
||||||
|
in comment blocks in the documentation this generates.
|
||||||
|
|
||||||
|
RDoc uses file extensions to determine how to process each file. File
|
||||||
|
names ending <tt>.rb</tt> and <tt>.rbw</tt> are assumed to be Ruby
|
||||||
|
source. Files ending <tt>.c</tt> are parsed as C files. All other
|
||||||
|
files are assumed to contain just SimpleMarkup-style markup (with or
|
||||||
|
without leading '#' comment markers). If directory names are passed to
|
||||||
|
RDoc, they are scanned recursively for C and Ruby source files only.
|
||||||
|
|
||||||
|
== Credits
|
||||||
|
|
||||||
|
* The Ruby parser in rdoc/parse.rb is based heavily on the outstanding
|
||||||
|
work of Keiju ISHITSUKA of Nippon Rational Inc, who produced the Ruby
|
||||||
|
parser for irb and the rtags package.
|
||||||
|
|
||||||
|
* Code to diagram classes and modules was written by Sergey A Yanovitsky
|
||||||
|
(Jah) of Enticla.
|
||||||
|
|
||||||
|
* Charset patch from MoonWolf.
|
||||||
|
|
||||||
|
* Rich Kilmer wrote the kilmer.rb output template.
|
||||||
|
|
||||||
|
* Dan Brickley led the design of the RDF format.
|
||||||
|
|
||||||
|
== License
|
||||||
|
|
||||||
|
RDoc is Copyright (c) 2001-2003 Dave Thomas, The Pragmatic Programmers. It
|
||||||
|
is free software, and may be redistributed under the terms specified
|
||||||
|
in the README file of the Ruby distribution.
|
||||||
|
|
||||||
|
|
||||||
|
----
|
||||||
|
|
||||||
|
= Usage
|
||||||
|
|
||||||
|
RDoc is invoked from the command line using:
|
||||||
|
|
||||||
|
% rdoc <options> [name...]
|
||||||
|
|
||||||
|
Files are parsed, and the information they contain collected, before
|
||||||
|
any output is produced. This allows cross references between all files
|
||||||
|
to be resolved. If a name is a directory, it is traversed. If no
|
||||||
|
names are specified, all Ruby files in the current directory (and
|
||||||
|
subdirectories) are processed.
|
||||||
|
|
||||||
|
Options are:
|
||||||
|
|
||||||
|
[<tt>--accessor</tt> <i>name[,name...]</i>]
|
||||||
|
specifies the name(s) of additional methods that should be treated
|
||||||
|
as if they were <tt>attr_</tt><i>xxx</i> methods. Specifying
|
||||||
|
"--accessor db_opt" means lines such as
|
||||||
|
|
||||||
|
db_opt :name, :age
|
||||||
|
|
||||||
|
will get parsed and displayed in the documentation. Each name may have an
|
||||||
|
optional "=flagtext" appended, in which case the given flagtext will appear
|
||||||
|
where (for example) the 'rw' appears for attr_accessor.
|
||||||
|
|
||||||
|
[<tt>--all</tt>]
|
||||||
|
include protected and private methods in the output (by default
|
||||||
|
only public methods are included)
|
||||||
|
|
||||||
|
[<tt>--charset</tt> _charset_]
|
||||||
|
Set the character set for the generated HTML.
|
||||||
|
|
||||||
|
[<tt>--diagram</tt>]
|
||||||
|
include diagrams showing modules and classes. This is currently
|
||||||
|
an experimental feature, and may not be supported by all output
|
||||||
|
templates. You need dot V1.8.6 or later to use the --diagram
|
||||||
|
option correctly (http://www.research.att.com/sw/tools/graphviz/).
|
||||||
|
|
||||||
|
[<tt>--exclude</tt> <i>pattern</i>]
|
||||||
|
exclude files and directories matching this pattern from processing
|
||||||
|
|
||||||
|
[<tt>--extension</tt> <i>new=old</i>]
|
||||||
|
treat files ending <i>.new</i> as if they ended
|
||||||
|
<i>.old</i>. Saying '--extension cgi=rb' causes RDoc to treat .cgi
|
||||||
|
files as Ruby source.
|
||||||
|
|
||||||
|
[<tt>fileboxes</tt>]
|
||||||
|
Classes are put in boxes which represents files, where these
|
||||||
|
classes reside. Classes shared between more than one file are
|
||||||
|
shown with list of files that sharing them. Silently discarded if
|
||||||
|
--diagram is not given Experimental.
|
||||||
|
|
||||||
|
[<tt>--fmt</tt> _fmt_]
|
||||||
|
generate output in a particular format.
|
||||||
|
|
||||||
|
[<tt>--help</tt>]
|
||||||
|
generate a usage summary.
|
||||||
|
|
||||||
|
[<tt>--help-output</tt>]
|
||||||
|
explain the various output options.
|
||||||
|
|
||||||
|
[<tt>--image-format</tt> <i>gif/png/jpg/jpeg</i>]
|
||||||
|
sets output image format for diagrams. Can be png, gif, jpeg,
|
||||||
|
jpg. If this option is omitted, png is used. Requires --diagram.
|
||||||
|
|
||||||
|
[<tt>--include</tt> <i>dir,...</i>]
|
||||||
|
specify one or more directories to be searched when satisfying
|
||||||
|
:+include+: directives. Multiple <tt>--include</tt> options may be
|
||||||
|
given. The directory containing the file currently being processed
|
||||||
|
is always searched.
|
||||||
|
|
||||||
|
[<tt>--inline-source</tt>]
|
||||||
|
By default, the source code of methods is shown in a popup. With
|
||||||
|
this option, it's displayed inline.
|
||||||
|
|
||||||
|
[<tt>line-numbers</tt>]
|
||||||
|
include line numbers in the source code
|
||||||
|
|
||||||
|
[<tt>--main</tt> _name_]
|
||||||
|
set the class, module, or file to appear on the index page
|
||||||
|
|
||||||
|
[<tt>--one-file</tt>]
|
||||||
|
place all the output into a single file
|
||||||
|
|
||||||
|
[<tt>--op</tt> _dir_]
|
||||||
|
set the output directory to _dir_ (the default is the directory
|
||||||
|
"doc")
|
||||||
|
|
||||||
|
[<tt>--op-name</tt> _name_]
|
||||||
|
set the name of the output. Has no effect for HTML.
|
||||||
|
"doc")
|
||||||
|
|
||||||
|
[<tt>--opname</tt> _name_]
|
||||||
|
set the output name (has no effect for HTML).
|
||||||
|
|
||||||
|
[<tt>--promiscuous</tt>]
|
||||||
|
If a module or class is defined in more than one source file, and
|
||||||
|
you click on a particular file's name in the top navigation pane,
|
||||||
|
RDoc will normally only show you the inner classes and modules of
|
||||||
|
that class that are defined in the particular file. Using this
|
||||||
|
option makes it show all classes and modules defined in the class,
|
||||||
|
regardless of the file they were defined in.
|
||||||
|
|
||||||
|
[<tt>--quiet</tt>]
|
||||||
|
do not display progress messages
|
||||||
|
|
||||||
|
[<tt>--show-hash</tt>]
|
||||||
|
A name of the form #name in a comment is a possible hyperlink to
|
||||||
|
an instance method name. When displayed, the '#' is removed unless
|
||||||
|
this option is specified
|
||||||
|
|
||||||
|
[<tt>--style</tt> <i>stylesheet url</i>]
|
||||||
|
specifies the URL of an external stylesheet to use (rather than
|
||||||
|
generating one of our own)
|
||||||
|
|
||||||
|
[<tt>tab-width</tt> _n_]
|
||||||
|
set the width of tab characters (default 8)
|
||||||
|
|
||||||
|
[<tt>--template</tt> <i>name</i>]
|
||||||
|
specify an alternate template to use when generating output (the
|
||||||
|
default is 'standard'). This template should be in a directory
|
||||||
|
accessible via $: as rdoc/generators/xxxx_template, where 'xxxx'
|
||||||
|
depends on the output formatter.
|
||||||
|
|
||||||
|
[<tt>--version</tt>]
|
||||||
|
display RDoc's version
|
||||||
|
|
||||||
|
[<tt>--webcvs</tt> _url_]
|
||||||
|
Specify a URL for linking to a web frontend to CVS. If the URL
|
||||||
|
contains a '\%s', the name of the current file will be
|
||||||
|
substituted; if the URL doesn't contain a '\%s', the filename will
|
||||||
|
be appended to it.
|
||||||
|
|
||||||
|
= Example
|
||||||
|
|
||||||
|
A typical small Ruby program commented using RDoc might be as follows. You
|
||||||
|
can see the formatted result in EXAMPLE.rb and Anagram.
|
||||||
|
|
||||||
|
:include: EXAMPLE.rb
|
||||||
|
|
||||||
|
= Markup
|
||||||
|
|
||||||
|
Comment blocks can be written fairly naturally.
|
||||||
|
|
||||||
|
Paragraphs are lines that share the left margin. Text indented past
|
||||||
|
this margin are formatted verbatim.
|
||||||
|
|
||||||
|
1. Lists are typed as indented paragraphs with:
|
||||||
|
* a '*' or '-' (for bullet lists)
|
||||||
|
* a digit followed by a period for
|
||||||
|
numbered lists
|
||||||
|
* an upper or lower case letter followed
|
||||||
|
by a period for alpha lists.
|
||||||
|
|
||||||
|
For example, the input that produced the above paragraph looked like
|
||||||
|
1. Lists are typed as indented
|
||||||
|
paragraphs with:
|
||||||
|
* a '*' or '-' (for bullet lists)
|
||||||
|
* a digit followed by a period for
|
||||||
|
numbered lists
|
||||||
|
* an upper or lower case letter followed
|
||||||
|
by a period for alpha lists.
|
||||||
|
|
||||||
|
2. Labeled lists (sometimes called description
|
||||||
|
lists) are typed using square brackets for the label.
|
||||||
|
[cat] small domestic animal
|
||||||
|
[+cat+] command to copy standard input
|
||||||
|
|
||||||
|
3. Labeled lists may also be produced by putting a double colon
|
||||||
|
after the label. This sets the result in tabular form, so the
|
||||||
|
descriptions all line up. This was used to create the 'author'
|
||||||
|
block at the bottom of this description.
|
||||||
|
cat:: small domestic animal
|
||||||
|
+cat+:: command to copy standard input
|
||||||
|
|
||||||
|
For both kinds of labeled lists, if the body text starts on the same
|
||||||
|
line as the label, then the start of that text determines the block
|
||||||
|
indent for the rest of the body. The text may also start on the line
|
||||||
|
following the label, indented from the start of the label. This is
|
||||||
|
often preferable if the label is long. Both the following are
|
||||||
|
valid labeled list entries:
|
||||||
|
|
||||||
|
<tt>--output</tt> <i>name [, name]</i>::
|
||||||
|
specify the name of one or more output files. If multiple
|
||||||
|
files are present, the first is used as the index.
|
||||||
|
|
||||||
|
<tt>--quiet:</tt>:: do not output the names, sizes, byte counts,
|
||||||
|
index areas, or bit ratios of units as
|
||||||
|
they are processed.
|
||||||
|
|
||||||
|
4. Headings are entered using equals signs
|
||||||
|
|
||||||
|
= Level One Heading
|
||||||
|
== Level Two Heading
|
||||||
|
and so on
|
||||||
|
|
||||||
|
5. Rules (horizontal lines) are entered using three or
|
||||||
|
more hyphens.
|
||||||
|
|
||||||
|
6. Non-verbatim text can be marked up:
|
||||||
|
|
||||||
|
_italic_:: \_word_ or \<em>text</em>
|
||||||
|
*bold*:: \*word* or \<b>text</b>
|
||||||
|
+typewriter+:: \+word+ or \<tt>text</tt>
|
||||||
|
|
||||||
|
The first form only works around 'words', where a word is a
|
||||||
|
sequence of upper and lower case letters and underscores. Putting a
|
||||||
|
backslash before inline markup stops it being interpreted, which is
|
||||||
|
how I created the table above:
|
||||||
|
|
||||||
|
_italic_:: \_word_ or \<em>text</em>
|
||||||
|
*bold*:: \*word* or \<b>text</b>
|
||||||
|
+typewriter+:: \+word+ or \<tt>text</tt>
|
||||||
|
|
||||||
|
7. Names of classes, source files, and any method names
|
||||||
|
containing an underscore or preceded by a hash
|
||||||
|
character are automatically hyperlinked from
|
||||||
|
comment text to their description.
|
||||||
|
|
||||||
|
8. Hyperlinks to the web starting http:, mailto:, ftp:, or www. are
|
||||||
|
recognized. An HTTP url that references an external image file is
|
||||||
|
converted into an inline <IMG..>. Hyperlinks starting 'link:' are
|
||||||
|
assumed to refer to local files whose path is relative to the --op
|
||||||
|
directory.
|
||||||
|
|
||||||
|
Hyperlinks can also be of the form <tt>label</tt>[url], in which
|
||||||
|
case the label is used in the displayed text, and <tt>url</tt> is
|
||||||
|
used as the target.
|
||||||
|
|
||||||
|
9. Method parameter lists are extracted and displayed with
|
||||||
|
the method description. If a method calls +yield+, then
|
||||||
|
the parameters passed to yield will also be displayed:
|
||||||
|
|
||||||
|
def fred
|
||||||
|
...
|
||||||
|
yield line, address
|
||||||
|
|
||||||
|
This will get documented as
|
||||||
|
|
||||||
|
fred() { |line, address| ... }
|
||||||
|
|
||||||
|
You can override this using a comment containing
|
||||||
|
':yields: ...' immediately after the method definition
|
||||||
|
|
||||||
|
def fred # :yields: index, position
|
||||||
|
...
|
||||||
|
yield line, address
|
||||||
|
|
||||||
|
which will get documented as
|
||||||
|
|
||||||
|
fred() { |index, position| ... }
|
||||||
|
|
||||||
|
|
||||||
|
10. ':yields:' is an example of a documentation modifier. These appear
|
||||||
|
immediately after the start of the document element they are modifying.
|
||||||
|
Other modifiers include
|
||||||
|
|
||||||
|
[<tt>:nodoc:</tt><i>[all]</i>]
|
||||||
|
don't include this element in the documentation. For classes
|
||||||
|
and modules, the methods, aliases, constants, and attributes
|
||||||
|
directly within the affected class or module will also be
|
||||||
|
omitted. By default, though, modules and classes within that
|
||||||
|
class of module _will_ be documented. This is turned off by
|
||||||
|
adding the +all+ modifier.
|
||||||
|
|
||||||
|
module SM #:nodoc:
|
||||||
|
class Input
|
||||||
|
end
|
||||||
|
end
|
||||||
|
module Markup #:nodoc: all
|
||||||
|
class Output
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
In the above code, only class <tt>SM::Input</tt> will be
|
||||||
|
documented.
|
||||||
|
|
||||||
|
[<tt>:doc:</tt>]
|
||||||
|
force a method or attribute to be documented even if it
|
||||||
|
wouldn't otherwise be. Useful if, for example, you want to
|
||||||
|
include documentation of a particular private method.
|
||||||
|
|
||||||
|
[<tt>:notnew:</tt>]
|
||||||
|
only applicable to the +initialize+ instance method. Normally
|
||||||
|
RDoc assumes that the documentation and parameters for
|
||||||
|
#initialize are actually for the ::new method, and so fakes
|
||||||
|
out a ::new for the class. THe :notnew: modifier stops
|
||||||
|
this. Remember that #initialize is protected, so you won't
|
||||||
|
see the documentation unless you use the -a command line
|
||||||
|
option.
|
||||||
|
|
||||||
|
|
||||||
|
11. RDoc stops processing comments if it finds a comment
|
||||||
|
line containing '<tt>#--</tt>'. This can be used to
|
||||||
|
separate external from internal comments, or
|
||||||
|
to stop a comment being associated with a method,
|
||||||
|
class, or module. Commenting can be turned back on with
|
||||||
|
a line that starts '<tt>#++</tt>'.
|
||||||
|
|
||||||
|
# Extract the age and calculate the
|
||||||
|
# date-of-birth.
|
||||||
|
#--
|
||||||
|
# FIXME: fails if the birthday falls on
|
||||||
|
# February 29th
|
||||||
|
#++
|
||||||
|
# The DOB is returned as a Time object.
|
||||||
|
|
||||||
|
def get_dob(person)
|
||||||
|
...
|
||||||
|
|
||||||
|
12. Comment blocks can contain other directives:
|
||||||
|
|
||||||
|
[<tt>:include:</tt><i>filename</i>]
|
||||||
|
include the contents of the named file at this point. The
|
||||||
|
file will be searched for in the directories listed by
|
||||||
|
the <tt>--include</tt> option, or in the current
|
||||||
|
directory by default. The contents of the file will be
|
||||||
|
shifted to have the same indentation as the ':' at the
|
||||||
|
start of the :include: directive.
|
||||||
|
|
||||||
|
[<tt>:title:</tt><i>text</i>]
|
||||||
|
Sets the title for the document. Equivalent to the --title command
|
||||||
|
line parameter. (The command line parameter overrides any :title:
|
||||||
|
directive in the source).
|
||||||
|
|
||||||
|
[<tt>:enddoc:</tt>]
|
||||||
|
Document nothing further at the current level.
|
||||||
|
|
||||||
|
[<tt>:main:</tt><i>name</i>]
|
||||||
|
Equivalent to the --main command line parameter.
|
||||||
|
|
||||||
|
[<tt>:stopdoc: / :startdoc:</tt>]
|
||||||
|
Stop and start adding new documentation elements to the
|
||||||
|
current container. For example, if a class has a number of
|
||||||
|
constants that you don't want to document, put a
|
||||||
|
<tt>:stopdoc:</tt> before the first, and a
|
||||||
|
<tt>:startdoc:</tt> after the last. If you don't specifiy a
|
||||||
|
<tt>:startdoc:</tt> by the end of the container, disables
|
||||||
|
documentation for the entire class or module.
|
||||||
|
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
See also markup/simple_markup.rb.
|
||||||
|
|
||||||
|
= Other stuff
|
||||||
|
|
||||||
|
Author:: Dave Thomas <dave@pragmaticprogrammer.com>
|
||||||
|
Requires:: Ruby 1.8.1 or later
|
||||||
|
License:: Copyright (c) 2001-2003 Dave Thomas.
|
||||||
|
Released under the same license as Ruby.
|
||||||
|
|
||||||
|
== Warranty
|
||||||
|
|
||||||
|
This software is provided "as is" and without any express or
|
||||||
|
implied warranties, including, without limitation, the implied
|
||||||
|
warranties of merchantibility and fitness for a particular
|
||||||
|
purpose.
|
||||||
653
lib/rdoc/code_objects.rb
Normal file
653
lib/rdoc/code_objects.rb
Normal file
|
|
@ -0,0 +1,653 @@
|
||||||
|
# We represent the various high-level code constructs that appear
|
||||||
|
# in Ruby programs: classes, modules, methods, and so on.
|
||||||
|
|
||||||
|
require 'rdoc/tokenstream'
|
||||||
|
|
||||||
|
module RDoc
|
||||||
|
|
||||||
|
|
||||||
|
# We contain the common stuff for contexts (which are containers)
|
||||||
|
# and other elements (methods, attributes and so on)
|
||||||
|
#
|
||||||
|
class CodeObject
|
||||||
|
|
||||||
|
attr_accessor :parent
|
||||||
|
|
||||||
|
# We are the model of the code, but we know that at some point
|
||||||
|
# we will be worked on by viewers. By implementing the Viewable
|
||||||
|
# protocol, viewers can associated themselves with these objects.
|
||||||
|
|
||||||
|
attr_accessor :viewer
|
||||||
|
|
||||||
|
# are we done documenting (ie, did we come across a :enddoc:)?
|
||||||
|
|
||||||
|
attr_accessor :done_documenting
|
||||||
|
|
||||||
|
|
||||||
|
# do we document ourselves?
|
||||||
|
|
||||||
|
attr_reader :document_self
|
||||||
|
|
||||||
|
def document_self=(val)
|
||||||
|
@document_self = val
|
||||||
|
if !val
|
||||||
|
remove_methods_etc
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
# set and cleared by :startdoc: and :enddoc:, this is used to toggle
|
||||||
|
# the capturing of documentation
|
||||||
|
def start_doc
|
||||||
|
@document_self = true
|
||||||
|
@document_children = true
|
||||||
|
end
|
||||||
|
|
||||||
|
def stop_doc
|
||||||
|
@document_self = false
|
||||||
|
@document_children = false
|
||||||
|
end
|
||||||
|
|
||||||
|
# do we document ourselves and our children
|
||||||
|
|
||||||
|
attr_reader :document_children
|
||||||
|
|
||||||
|
def document_children=(val)
|
||||||
|
@document_children = val
|
||||||
|
if !val
|
||||||
|
remove_classes_and_modules
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
# Do we _force_ documentation, even is we wouldn't normally show the entity
|
||||||
|
attr_accessor :force_documentation
|
||||||
|
|
||||||
|
# Default callbacks to nothing, but this is overridden for classes
|
||||||
|
# and modules
|
||||||
|
def remove_classes_and_modules
|
||||||
|
end
|
||||||
|
|
||||||
|
def remove_methods_etc
|
||||||
|
end
|
||||||
|
|
||||||
|
def initialize
|
||||||
|
@document_self = true
|
||||||
|
@document_children = true
|
||||||
|
@force_documentation = false
|
||||||
|
@done_documenting = false
|
||||||
|
end
|
||||||
|
|
||||||
|
# Access the code object's comment
|
||||||
|
attr_reader :comment
|
||||||
|
|
||||||
|
# Update the comment, but don't overwrite a real comment
|
||||||
|
# with an empty one
|
||||||
|
def comment=(comment)
|
||||||
|
@comment = comment unless comment.empty?
|
||||||
|
end
|
||||||
|
|
||||||
|
# There's a wee trick we pull. Comment blocks can have directives that
|
||||||
|
# override the stuff we extract during the parse. So, we have a special
|
||||||
|
# class method, attr_overridable, that lets code objects list
|
||||||
|
# those directives. Wehn a comment is assigned, we then extract
|
||||||
|
# out any matching directives and update our object
|
||||||
|
|
||||||
|
def CodeObject.attr_overridable(name, *aliases)
|
||||||
|
@overridables ||= {}
|
||||||
|
|
||||||
|
attr_accessor name
|
||||||
|
|
||||||
|
aliases.unshift name
|
||||||
|
aliases.each do |directive_name|
|
||||||
|
@overridables[directive_name.to_s] = name
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
end
|
||||||
|
|
||||||
|
# A Context is something that can hold modules, classes, methods,
|
||||||
|
# attributes, aliases, requires, and includes. Classes, modules, and
|
||||||
|
# files are all Contexts.
|
||||||
|
|
||||||
|
class Context < CodeObject
|
||||||
|
attr_reader :name, :method_list, :attributes, :aliases, :constants
|
||||||
|
attr_reader :requires, :includes, :in_files, :visibility
|
||||||
|
|
||||||
|
|
||||||
|
def initialize
|
||||||
|
super()
|
||||||
|
|
||||||
|
@in_files = []
|
||||||
|
|
||||||
|
@name ||= "unknown"
|
||||||
|
@comment ||= ""
|
||||||
|
@parent = nil
|
||||||
|
@visibility = :public
|
||||||
|
|
||||||
|
initialize_methods_etc
|
||||||
|
initialize_classes_and_modules
|
||||||
|
end
|
||||||
|
|
||||||
|
# map the class hash to an array externally
|
||||||
|
def classes
|
||||||
|
@classes.values
|
||||||
|
end
|
||||||
|
|
||||||
|
# map the module hash to an array externally
|
||||||
|
def modules
|
||||||
|
@modules.values
|
||||||
|
end
|
||||||
|
|
||||||
|
# Change the default visibility for new methods
|
||||||
|
def ongoing_visibility=(vis)
|
||||||
|
@visibility = vis
|
||||||
|
end
|
||||||
|
|
||||||
|
# Given an array +methods+ of method names, set the
|
||||||
|
# visibility of the corresponding AnyMethod object
|
||||||
|
|
||||||
|
def set_visibility_for(methods, vis, singleton=false)
|
||||||
|
@method_list.each_with_index do |m,i|
|
||||||
|
if methods.include?(m.name) && m.singleton == singleton
|
||||||
|
m.visibility = vis
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
# Record the file that we happen to find it in
|
||||||
|
def record_location(toplevel)
|
||||||
|
@in_files << toplevel unless @in_files.include?(toplevel)
|
||||||
|
end
|
||||||
|
|
||||||
|
# Return true if at least part of this thing was defined in +file+
|
||||||
|
def defined_in?(file)
|
||||||
|
@in_files.include?(file)
|
||||||
|
end
|
||||||
|
|
||||||
|
def add_class(class_type, name, superclass)
|
||||||
|
add_class_or_module(@classes, class_type, name, superclass)
|
||||||
|
end
|
||||||
|
|
||||||
|
def add_module(class_type, name)
|
||||||
|
add_class_or_module(@modules, class_type, name, nil)
|
||||||
|
end
|
||||||
|
|
||||||
|
def add_method(a_method)
|
||||||
|
puts "Adding #@visibility method #{a_method.name} to #@name" if $DEBUG
|
||||||
|
a_method.visibility = @visibility
|
||||||
|
add_to(@method_list, a_method)
|
||||||
|
end
|
||||||
|
|
||||||
|
def add_attribute(an_attribute)
|
||||||
|
add_to(@attributes, an_attribute)
|
||||||
|
end
|
||||||
|
|
||||||
|
def add_alias(an_alias)
|
||||||
|
meth = find_method_named(an_alias.old_name)
|
||||||
|
if meth
|
||||||
|
new_meth = AnyMethod.new(an_alias.text, an_alias.new_name)
|
||||||
|
new_meth.is_alias_for = meth
|
||||||
|
new_meth.singleton = meth.singleton
|
||||||
|
new_meth.params = meth.params
|
||||||
|
new_meth.comment = "Alias for \##{meth.name}"
|
||||||
|
meth.add_alias(new_meth)
|
||||||
|
add_method(new_meth)
|
||||||
|
else
|
||||||
|
add_to(@aliases, an_alias)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
def add_include(an_include)
|
||||||
|
add_to(@includes, an_include)
|
||||||
|
end
|
||||||
|
|
||||||
|
def add_constant(const)
|
||||||
|
add_to(@constants, const)
|
||||||
|
end
|
||||||
|
|
||||||
|
# Requires always get added to the top-level (file) context
|
||||||
|
def add_require(a_require)
|
||||||
|
if self.kind_of? TopLevel
|
||||||
|
add_to(@requires, a_require)
|
||||||
|
else
|
||||||
|
parent.add_require(a_require)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
def add_class_or_module(collection, class_type, name, superclass=nil)
|
||||||
|
cls = collection[name]
|
||||||
|
if cls
|
||||||
|
puts "Reusing class/module #{name}" if $DEBUG
|
||||||
|
else
|
||||||
|
cls = class_type.new(name, superclass)
|
||||||
|
puts "Adding class/module #{name} to #@name" if $DEBUG
|
||||||
|
collection[name] = cls
|
||||||
|
cls.parent = self
|
||||||
|
end
|
||||||
|
cls
|
||||||
|
end
|
||||||
|
|
||||||
|
def add_to(array, thing)
|
||||||
|
array << thing if @document_self
|
||||||
|
thing.parent = self
|
||||||
|
end
|
||||||
|
|
||||||
|
# If a class's documentation is turned off after we've started
|
||||||
|
# collecting methods etc., we need to remove the ones
|
||||||
|
# we have
|
||||||
|
|
||||||
|
def remove_methods_etc
|
||||||
|
initialize_methods_etc
|
||||||
|
end
|
||||||
|
|
||||||
|
def initialize_methods_etc
|
||||||
|
@method_list = []
|
||||||
|
@attributes = []
|
||||||
|
@aliases = []
|
||||||
|
@requires = []
|
||||||
|
@includes = []
|
||||||
|
@constants = []
|
||||||
|
end
|
||||||
|
|
||||||
|
# and remove classes and modules when we see a :nodoc: all
|
||||||
|
def remove_classes_and_modules
|
||||||
|
initialize_classes_and_modules
|
||||||
|
end
|
||||||
|
|
||||||
|
def initialize_classes_and_modules
|
||||||
|
@classes = {}
|
||||||
|
@modules = {}
|
||||||
|
end
|
||||||
|
|
||||||
|
# Find a named module
|
||||||
|
def find_module_named(name)
|
||||||
|
return self if self.name == name
|
||||||
|
res = @modules[name] || @classes[name]
|
||||||
|
return res if res
|
||||||
|
parent && parent.find_module_named(name)
|
||||||
|
end
|
||||||
|
|
||||||
|
# Iterate over all the classes and modules in
|
||||||
|
# this object
|
||||||
|
|
||||||
|
def each_classmodule
|
||||||
|
@modules.each_value {|m| yield m}
|
||||||
|
@classes.each_value {|c| yield c}
|
||||||
|
end
|
||||||
|
|
||||||
|
def each_method
|
||||||
|
@method_list.each {|m| yield m}
|
||||||
|
end
|
||||||
|
|
||||||
|
def each_attribute
|
||||||
|
@attributes.each {|a| yield a}
|
||||||
|
end
|
||||||
|
|
||||||
|
def each_constant
|
||||||
|
@constants.each {|c| yield c}
|
||||||
|
end
|
||||||
|
|
||||||
|
# Return the toplevel that owns us
|
||||||
|
|
||||||
|
def toplevel
|
||||||
|
return @toplevel if defined? @toplevel
|
||||||
|
@toplevel = self
|
||||||
|
@toplevel = @toplevel.parent until TopLevel === @toplevel
|
||||||
|
@toplevel
|
||||||
|
end
|
||||||
|
|
||||||
|
# allow us to sort modules by name
|
||||||
|
def <=>(other)
|
||||||
|
name <=> other.name
|
||||||
|
end
|
||||||
|
|
||||||
|
# Look up the given symbol. If method is non-nil, then
|
||||||
|
# we assume the symbol references a module that
|
||||||
|
# contains that method
|
||||||
|
def find_symbol(symbol, method=nil)
|
||||||
|
result = nil
|
||||||
|
case symbol
|
||||||
|
when /^::(.*)/
|
||||||
|
result = toplevel.find_symbol(symbol)
|
||||||
|
when /::/
|
||||||
|
modules = symbol.split(/::/)
|
||||||
|
unless modules.empty?
|
||||||
|
module_name = modules.shift
|
||||||
|
result = find_module_named(module_name)
|
||||||
|
if result
|
||||||
|
modules.each do |module_name|
|
||||||
|
result = result.find_module_named(module_name)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
else
|
||||||
|
result = find_local_symbol(symbol)
|
||||||
|
if result.nil?
|
||||||
|
if symbol =~ /^[A-Z]/
|
||||||
|
result = parent
|
||||||
|
while result && result.name != symbol
|
||||||
|
result = result.parent
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
if result && method
|
||||||
|
result = result.find_local_symbol(method)
|
||||||
|
end
|
||||||
|
result
|
||||||
|
end
|
||||||
|
|
||||||
|
def find_local_symbol(symbol)
|
||||||
|
res = find_method_named(symbol) ||
|
||||||
|
find_constant_named(symbol) ||
|
||||||
|
find_attribute_named(symbol) ||
|
||||||
|
find_module_named(symbol)
|
||||||
|
end
|
||||||
|
|
||||||
|
private
|
||||||
|
|
||||||
|
# Find a named method, or return nil
|
||||||
|
def find_method_named(name)
|
||||||
|
@method_list.find {|meth| meth.name == name}
|
||||||
|
end
|
||||||
|
|
||||||
|
# Find a named constant, or return nil
|
||||||
|
def find_constant_named(name)
|
||||||
|
@constants.find {|m| m.name == name}
|
||||||
|
end
|
||||||
|
|
||||||
|
# Find a named attribute, or return nil
|
||||||
|
def find_attribute_named(name)
|
||||||
|
@attributes.find {|m| m.name == name}
|
||||||
|
end
|
||||||
|
|
||||||
|
end
|
||||||
|
|
||||||
|
|
||||||
|
# A TopLevel context is a source file
|
||||||
|
|
||||||
|
class TopLevel < Context
|
||||||
|
attr_accessor :file_stat
|
||||||
|
attr_accessor :file_relative_name
|
||||||
|
attr_accessor :file_absolute_name
|
||||||
|
attr_accessor :diagram
|
||||||
|
|
||||||
|
@@all_classes = {}
|
||||||
|
@@all_modules = {}
|
||||||
|
|
||||||
|
def TopLevel::reset
|
||||||
|
@@all_classes = {}
|
||||||
|
@@all_modules = {}
|
||||||
|
end
|
||||||
|
|
||||||
|
def initialize(file_name)
|
||||||
|
super()
|
||||||
|
@name = "TopLevel"
|
||||||
|
@file_relative_name = file_name
|
||||||
|
@file_absolute_name = file_name
|
||||||
|
@file_stat = File.stat(file_name)
|
||||||
|
@diagram = nil
|
||||||
|
end
|
||||||
|
|
||||||
|
def full_name
|
||||||
|
nil
|
||||||
|
end
|
||||||
|
|
||||||
|
# Adding a class or module to a TopLevel is special, as we only
|
||||||
|
# want one copy of a particular top-level class. For example,
|
||||||
|
# if both file A and file B implement class C, we only want one
|
||||||
|
# ClassModule object for C. This code arranges to share
|
||||||
|
# classes and modules between files.
|
||||||
|
|
||||||
|
def add_class_or_module(collection, class_type, name, superclass)
|
||||||
|
cls = collection[name]
|
||||||
|
if cls
|
||||||
|
puts "Reusing class/module #{name}" if $DEBUG
|
||||||
|
else
|
||||||
|
if class_type == NormalModule
|
||||||
|
all = @@all_modules
|
||||||
|
else
|
||||||
|
all = @@all_classes
|
||||||
|
end
|
||||||
|
cls = all[name]
|
||||||
|
if !cls
|
||||||
|
cls = class_type.new(name, superclass)
|
||||||
|
all[name] = cls
|
||||||
|
end
|
||||||
|
puts "Adding class/module #{name} to #@name" if $DEBUG
|
||||||
|
collection[name] = cls
|
||||||
|
cls.parent = self
|
||||||
|
end
|
||||||
|
cls
|
||||||
|
end
|
||||||
|
|
||||||
|
def TopLevel.all_classes_and_modules
|
||||||
|
@@all_classes.values + @@all_modules.values
|
||||||
|
end
|
||||||
|
|
||||||
|
def TopLevel.find_class_named(name)
|
||||||
|
@@all_classes.each_value do |c|
|
||||||
|
res = c.find_class_named(name)
|
||||||
|
return res if res
|
||||||
|
end
|
||||||
|
nil
|
||||||
|
end
|
||||||
|
|
||||||
|
def find_local_symbol(symbol)
|
||||||
|
find_class_or_module_named(symbol) || super
|
||||||
|
end
|
||||||
|
|
||||||
|
def find_class_or_module_named(symbol)
|
||||||
|
@@all_classes.each_value {|c| return c if c.name == symbol}
|
||||||
|
@@all_modules.each_value {|m| return m if m.name == symbol}
|
||||||
|
nil
|
||||||
|
end
|
||||||
|
|
||||||
|
end
|
||||||
|
|
||||||
|
# ClassModule is the base class for objects representing either a
|
||||||
|
# class or a module.
|
||||||
|
|
||||||
|
class ClassModule < Context
|
||||||
|
|
||||||
|
attr_reader :superclass
|
||||||
|
attr_accessor :diagram
|
||||||
|
|
||||||
|
def initialize(name, superclass = nil)
|
||||||
|
@name = name
|
||||||
|
@diagram = nil
|
||||||
|
@superclass = superclass
|
||||||
|
@comment = ""
|
||||||
|
super()
|
||||||
|
end
|
||||||
|
|
||||||
|
# Return the fully qualified name of this class or module
|
||||||
|
def full_name
|
||||||
|
if @parent && @parent.full_name
|
||||||
|
@parent.full_name + "::" + @name
|
||||||
|
else
|
||||||
|
@name
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
def http_url(prefix)
|
||||||
|
path = full_name.split("::")
|
||||||
|
File.join(prefix, *path) + ".html"
|
||||||
|
end
|
||||||
|
|
||||||
|
# Return +true+ if this object represents a module
|
||||||
|
def is_module?
|
||||||
|
false
|
||||||
|
end
|
||||||
|
|
||||||
|
# to_s is simply for debugging
|
||||||
|
def to_s
|
||||||
|
res = self.class.name + ": " + @name
|
||||||
|
res << @comment.to_s
|
||||||
|
res << super
|
||||||
|
res
|
||||||
|
end
|
||||||
|
|
||||||
|
def find_class_named(name)
|
||||||
|
return self if full_name == name
|
||||||
|
@classes.each_value {|c| return c if c.find_class_named(name) }
|
||||||
|
nil
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
# Anonymous classes
|
||||||
|
class AnonClass < ClassModule
|
||||||
|
end
|
||||||
|
|
||||||
|
# Normal classes
|
||||||
|
class NormalClass < ClassModule
|
||||||
|
end
|
||||||
|
|
||||||
|
# Singleton classes
|
||||||
|
class SingleClass < ClassModule
|
||||||
|
end
|
||||||
|
|
||||||
|
# Module
|
||||||
|
class NormalModule < ClassModule
|
||||||
|
def is_module?
|
||||||
|
true
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
|
||||||
|
# AnyMethod is the base class for objects representing methods
|
||||||
|
|
||||||
|
class AnyMethod < CodeObject
|
||||||
|
attr_accessor :name
|
||||||
|
attr_accessor :visibility
|
||||||
|
attr_accessor :block_params
|
||||||
|
attr_accessor :dont_rename_initialize
|
||||||
|
attr_accessor :singleton
|
||||||
|
attr_reader :aliases # list of other names for this method
|
||||||
|
attr_accessor :is_alias_for # or a method we're aliasing
|
||||||
|
|
||||||
|
attr_overridable :params, :param, :parameters, :parameter
|
||||||
|
|
||||||
|
include TokenStream
|
||||||
|
|
||||||
|
def initialize(text, name)
|
||||||
|
super()
|
||||||
|
@text = text
|
||||||
|
@name = name
|
||||||
|
@token_stream = nil
|
||||||
|
@visibility = :public
|
||||||
|
@dont_rename_initialize = false
|
||||||
|
@block_params = nil
|
||||||
|
@aliases = []
|
||||||
|
@is_alias_for = nil
|
||||||
|
@comment = ""
|
||||||
|
end
|
||||||
|
|
||||||
|
def <=>(other)
|
||||||
|
@name <=> other.name
|
||||||
|
end
|
||||||
|
|
||||||
|
def to_s
|
||||||
|
res = self.class.name + ": " + @name + " (" + @text + ")\n"
|
||||||
|
res << @comment.to_s
|
||||||
|
res
|
||||||
|
end
|
||||||
|
|
||||||
|
def param_seq
|
||||||
|
p = params.gsub(/\s*\#.*/, '')
|
||||||
|
p = p.tr("\n", " ").squeeze(" ")
|
||||||
|
p = "(" + p + ")" unless p[0] == ?(
|
||||||
|
|
||||||
|
if (block = block_params)
|
||||||
|
block.gsub!(/\s*\#.*/, '')
|
||||||
|
block = block.tr("\n", " ").squeeze(" ")
|
||||||
|
if block[0] == ?(
|
||||||
|
block.sub!(/^\(/, '').sub!(/\)/, '')
|
||||||
|
end
|
||||||
|
p << " {|#{block}| ...}"
|
||||||
|
end
|
||||||
|
p
|
||||||
|
end
|
||||||
|
|
||||||
|
def add_alias(method)
|
||||||
|
@aliases << method
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
|
||||||
|
# Represent an alias, which is an old_name/ new_name pair associated
|
||||||
|
# with a particular context
|
||||||
|
class Alias < CodeObject
|
||||||
|
attr_accessor :text, :old_name, :new_name, :comment
|
||||||
|
|
||||||
|
def initialize(text, old_name, new_name, comment)
|
||||||
|
super()
|
||||||
|
@text = text
|
||||||
|
@old_name = old_name
|
||||||
|
@new_name = new_name
|
||||||
|
self.comment = comment
|
||||||
|
end
|
||||||
|
|
||||||
|
def to_s
|
||||||
|
"alias: #{self.old_name} -> #{self.new_name}\n#{self.comment}"
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
# Represent a constant
|
||||||
|
class Constant < CodeObject
|
||||||
|
attr_accessor :name, :value
|
||||||
|
|
||||||
|
def initialize(name, value, comment)
|
||||||
|
super()
|
||||||
|
@name = name
|
||||||
|
@value = value
|
||||||
|
self.comment = comment
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
# Represent attributes
|
||||||
|
class Attr < CodeObject
|
||||||
|
attr_accessor :text, :name, :rw
|
||||||
|
|
||||||
|
def initialize(text, name, rw, comment)
|
||||||
|
super()
|
||||||
|
@text = text
|
||||||
|
@name = name
|
||||||
|
@rw = rw
|
||||||
|
self.comment = comment
|
||||||
|
end
|
||||||
|
|
||||||
|
def to_s
|
||||||
|
"attr: #{self.name} #{self.rw}\n#{self.comment}"
|
||||||
|
end
|
||||||
|
|
||||||
|
def <=>(other)
|
||||||
|
self.name <=> other.name
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
# a required file
|
||||||
|
|
||||||
|
class Require < CodeObject
|
||||||
|
attr_accessor :name
|
||||||
|
|
||||||
|
def initialize(name, comment)
|
||||||
|
super()
|
||||||
|
@name = name.gsub(/'|"/, "") #'
|
||||||
|
self.comment = comment
|
||||||
|
end
|
||||||
|
|
||||||
|
end
|
||||||
|
|
||||||
|
# an included module
|
||||||
|
class Include < CodeObject
|
||||||
|
attr_accessor :name
|
||||||
|
|
||||||
|
def initialize(name, comment)
|
||||||
|
super()
|
||||||
|
@name = name
|
||||||
|
self.comment = comment
|
||||||
|
end
|
||||||
|
|
||||||
|
end
|
||||||
|
|
||||||
|
end
|
||||||
333
lib/rdoc/diagram.rb
Normal file
333
lib/rdoc/diagram.rb
Normal file
|
|
@ -0,0 +1,333 @@
|
||||||
|
# A wonderful hack by to draw package diagrams using the dot package.
|
||||||
|
# Originally written by Jah, team Enticla.
|
||||||
|
#
|
||||||
|
# You must have the V1.7 or later in your path
|
||||||
|
# http://www.research.att.com/sw/tools/graphviz/
|
||||||
|
|
||||||
|
require "dot/dot"
|
||||||
|
require 'rdoc/options'
|
||||||
|
|
||||||
|
module RDoc
|
||||||
|
|
||||||
|
# Draw a set of diagrams representing the modules and classes in the
|
||||||
|
# system. We draw one diagram for each file, and one for each toplevel
|
||||||
|
# class or module. This means there will be overlap. However, it also
|
||||||
|
# means that you'll get better context for objects.
|
||||||
|
#
|
||||||
|
# To use, simply
|
||||||
|
#
|
||||||
|
# d = Diagram.new(info) # pass in collection of top level infos
|
||||||
|
# d.draw
|
||||||
|
#
|
||||||
|
# The results will be written to the +dot+ subdirectory. The process
|
||||||
|
# also sets the +diagram+ attribute in each object it graphs to
|
||||||
|
# the name of the file containing the image. This can be used
|
||||||
|
# by output generators to insert images.
|
||||||
|
|
||||||
|
class Diagram
|
||||||
|
|
||||||
|
FONT = "Arial"
|
||||||
|
|
||||||
|
DOT_PATH = "dot"
|
||||||
|
|
||||||
|
# Pass in the set of top level objects. The method also creates
|
||||||
|
# the subdirectory to hold the images
|
||||||
|
|
||||||
|
def initialize(info, options)
|
||||||
|
@info = info
|
||||||
|
@options = options
|
||||||
|
@counter = 0
|
||||||
|
File.makedirs(DOT_PATH)
|
||||||
|
end
|
||||||
|
|
||||||
|
# Draw the diagrams. We traverse the files, drawing a diagram for
|
||||||
|
# each. We also traverse each top-level class and module in that
|
||||||
|
# file drawing a diagram for these too.
|
||||||
|
|
||||||
|
def draw
|
||||||
|
unless @options.quiet
|
||||||
|
$stderr.print "Diagrams: "
|
||||||
|
$stderr.flush
|
||||||
|
end
|
||||||
|
|
||||||
|
@info.each_with_index do |i, file_count|
|
||||||
|
@done_modules = {}
|
||||||
|
@local_names = find_names(i)
|
||||||
|
@global_names = []
|
||||||
|
@global_graph = graph = DOT::DOTDigraph.new('name' => 'TopLevel',
|
||||||
|
'label' => i.file_absolute_name,
|
||||||
|
'fontname' => FONT,
|
||||||
|
'fontsize' => '8',
|
||||||
|
'bgcolor' => 'lightcyan1',
|
||||||
|
'compound' => 'true')
|
||||||
|
|
||||||
|
# it's a little hack %) i'm too lazy to create a separate class
|
||||||
|
# for default node
|
||||||
|
graph << DOT::DOTNode.new('name' => 'node',
|
||||||
|
'fontname' => FONT,
|
||||||
|
'color' => 'black',
|
||||||
|
'fontsize' => 8)
|
||||||
|
|
||||||
|
i.modules.each do |mod|
|
||||||
|
draw_module(mod, graph, true, i.file_relative_name)
|
||||||
|
end
|
||||||
|
add_classes(i, graph, i.file_relative_name)
|
||||||
|
|
||||||
|
i.diagram = convert_to_png("f_#{file_count}", graph, i.name)
|
||||||
|
|
||||||
|
# now go through and document each top level class and
|
||||||
|
# module independently
|
||||||
|
i.modules.each_with_index do |mod, count|
|
||||||
|
@done_modules = {}
|
||||||
|
@local_names = find_names(mod)
|
||||||
|
@global_names = []
|
||||||
|
|
||||||
|
@global_graph = graph = DOT::DOTDigraph.new('name' => 'TopLevel',
|
||||||
|
'label' => i.full_name,
|
||||||
|
'fontname' => FONT,
|
||||||
|
'fontsize' => '8',
|
||||||
|
'bgcolor' => 'lightcyan1',
|
||||||
|
'compound' => 'true')
|
||||||
|
|
||||||
|
graph << DOT::DOTNode.new('name' => 'node',
|
||||||
|
'fontname' => FONT,
|
||||||
|
'color' => 'black',
|
||||||
|
'fontsize' => 8)
|
||||||
|
draw_module(mod, graph, true)
|
||||||
|
mod.diagram = convert_to_png("m_#{file_count}_#{count}",
|
||||||
|
graph,
|
||||||
|
"Module: #{mod.name}")
|
||||||
|
end
|
||||||
|
end
|
||||||
|
$stderr.puts unless @options.quiet
|
||||||
|
end
|
||||||
|
|
||||||
|
#######
|
||||||
|
private
|
||||||
|
#######
|
||||||
|
|
||||||
|
def find_names(mod)
|
||||||
|
return [mod.full_name] + mod.classes.collect{|cl| cl.full_name} +
|
||||||
|
mod.modules.collect{|m| find_names(m)}.flatten
|
||||||
|
end
|
||||||
|
|
||||||
|
def find_full_name(name, mod)
|
||||||
|
full_name = name.dup
|
||||||
|
return full_name if @local_names.include?(full_name)
|
||||||
|
mod_path = mod.full_name.split('::')[0..-2]
|
||||||
|
unless mod_path.nil?
|
||||||
|
until mod_path.empty?
|
||||||
|
full_name = mod_path.pop + '::' + full_name
|
||||||
|
return full_name if @local_names.include?(full_name)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
return name
|
||||||
|
end
|
||||||
|
|
||||||
|
def draw_module(mod, graph, toplevel = false, file = nil)
|
||||||
|
return if @done_modules[mod.full_name] and not toplevel
|
||||||
|
|
||||||
|
@counter += 1
|
||||||
|
url = mod.http_url("classes")
|
||||||
|
m = DOT::DOTSubgraph.new('name' => "cluster_#{mod.full_name.gsub( /:/,'_' )}",
|
||||||
|
'label' => mod.name,
|
||||||
|
'fontname' => FONT,
|
||||||
|
'color' => 'blue',
|
||||||
|
'style' => 'filled',
|
||||||
|
'URL' => %{"#{url}"},
|
||||||
|
'fillcolor' => toplevel ? 'palegreen1' : 'palegreen3')
|
||||||
|
|
||||||
|
@done_modules[mod.full_name] = m
|
||||||
|
add_classes(mod, m, file)
|
||||||
|
graph << m
|
||||||
|
|
||||||
|
unless mod.includes.empty?
|
||||||
|
mod.includes.each do |m|
|
||||||
|
m_full_name = find_full_name(m.name, mod)
|
||||||
|
if @local_names.include?(m_full_name)
|
||||||
|
@global_graph << DOT::DOTEdge.new('from' => "#{m_full_name.gsub( /:/,'_' )}",
|
||||||
|
'to' => "#{mod.full_name.gsub( /:/,'_' )}",
|
||||||
|
'ltail' => "cluster_#{m_full_name.gsub( /:/,'_' )}",
|
||||||
|
'lhead' => "cluster_#{mod.full_name.gsub( /:/,'_' )}")
|
||||||
|
else
|
||||||
|
unless @global_names.include?(m_full_name)
|
||||||
|
path = m_full_name.split("::")
|
||||||
|
url = File.join('classes', *path) + ".html"
|
||||||
|
@global_graph << DOT::DOTNode.new('name' => "#{m_full_name.gsub( /:/,'_' )}",
|
||||||
|
'shape' => 'box',
|
||||||
|
'label' => "#{m_full_name}",
|
||||||
|
'URL' => %{"#{url}"})
|
||||||
|
@global_names << m_full_name
|
||||||
|
end
|
||||||
|
@global_graph << DOT::DOTEdge.new('from' => "#{m_full_name.gsub( /:/,'_' )}",
|
||||||
|
'to' => "#{mod.full_name.gsub( /:/,'_' )}",
|
||||||
|
'lhead' => "cluster_#{mod.full_name.gsub( /:/,'_' )}")
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
def add_classes(container, graph, file = nil )
|
||||||
|
|
||||||
|
use_fileboxes = Options.instance.fileboxes
|
||||||
|
|
||||||
|
files = {}
|
||||||
|
|
||||||
|
# create dummy node (needed if empty and for module includes)
|
||||||
|
if container.full_name
|
||||||
|
graph << DOT::DOTNode.new('name' => "#{container.full_name.gsub( /:/,'_' )}",
|
||||||
|
'label' => "",
|
||||||
|
'width' => (container.classes.empty? and
|
||||||
|
container.modules.empty?) ?
|
||||||
|
'0.75' : '0.01',
|
||||||
|
'height' => '0.01',
|
||||||
|
'shape' => 'plaintext')
|
||||||
|
end
|
||||||
|
container.classes.each_with_index do |cl, cl_index|
|
||||||
|
last_file = cl.in_files[-1].file_relative_name
|
||||||
|
|
||||||
|
if use_fileboxes && !files.include?(last_file)
|
||||||
|
@counter += 1
|
||||||
|
files[last_file] =
|
||||||
|
DOT::DOTSubgraph.new('name' => "cluster_#{@counter}",
|
||||||
|
'label' => "#{last_file}",
|
||||||
|
'fontname' => FONT,
|
||||||
|
'color'=>
|
||||||
|
last_file == file ? 'red' : 'black')
|
||||||
|
end
|
||||||
|
|
||||||
|
next if cl.name == 'Object' || cl.name[0,2] == "<<"
|
||||||
|
|
||||||
|
url = cl.http_url("classes")
|
||||||
|
|
||||||
|
label = cl.name.dup
|
||||||
|
if use_fileboxes && cl.in_files.length > 1
|
||||||
|
label << '\n[' +
|
||||||
|
cl.in_files.collect {|i|
|
||||||
|
i.file_relative_name
|
||||||
|
}.sort.join( '\n' ) +
|
||||||
|
']'
|
||||||
|
end
|
||||||
|
|
||||||
|
attrs = {
|
||||||
|
'name' => "#{cl.full_name.gsub( /:/, '_' )}",
|
||||||
|
'fontcolor' => 'black',
|
||||||
|
'style'=>'filled',
|
||||||
|
'color'=>'palegoldenrod',
|
||||||
|
'label' => label,
|
||||||
|
'shape' => 'ellipse',
|
||||||
|
'URL' => %{"#{url}"}
|
||||||
|
}
|
||||||
|
|
||||||
|
c = DOT::DOTNode.new(attrs)
|
||||||
|
|
||||||
|
if use_fileboxes
|
||||||
|
files[last_file].push c
|
||||||
|
else
|
||||||
|
graph << c
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
if use_fileboxes
|
||||||
|
files.each_value do |val|
|
||||||
|
graph << val
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
unless container.classes.empty?
|
||||||
|
container.classes.each_with_index do |cl, cl_index|
|
||||||
|
cl.includes.each do |m|
|
||||||
|
m_full_name = find_full_name(m.name, cl)
|
||||||
|
if @local_names.include?(m_full_name)
|
||||||
|
@global_graph << DOT::DOTEdge.new('from' => "#{m_full_name.gsub( /:/,'_' )}",
|
||||||
|
'to' => "#{cl.full_name.gsub( /:/,'_' )}",
|
||||||
|
'ltail' => "cluster_#{m_full_name.gsub( /:/,'_' )}")
|
||||||
|
else
|
||||||
|
unless @global_names.include?(m_full_name)
|
||||||
|
path = m_full_name.split("::")
|
||||||
|
url = File.join('classes', *path) + ".html"
|
||||||
|
@global_graph << DOT::DOTNode.new('name' => "#{m_full_name.gsub( /:/,'_' )}",
|
||||||
|
'shape' => 'box',
|
||||||
|
'label' => "#{m_full_name}",
|
||||||
|
'URL' => %{"#{url}"})
|
||||||
|
@global_names << m_full_name
|
||||||
|
end
|
||||||
|
@global_graph << DOT::DOTEdge.new('from' => "#{m_full_name.gsub( /:/,'_' )}",
|
||||||
|
'to' => "#{cl.full_name.gsub( /:/, '_')}")
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
sclass = cl.superclass
|
||||||
|
next if sclass.nil? || sclass == 'Object'
|
||||||
|
sclass_full_name = find_full_name(sclass,cl)
|
||||||
|
unless @local_names.include?(sclass_full_name) or @global_names.include?(sclass_full_name)
|
||||||
|
path = sclass_full_name.split("::")
|
||||||
|
url = File.join('classes', *path) + ".html"
|
||||||
|
@global_graph << DOT::DOTNode.new(
|
||||||
|
'name' => "#{sclass_full_name.gsub( /:/, '_' )}",
|
||||||
|
'label' => sclass_full_name,
|
||||||
|
'URL' => %{"#{url}"})
|
||||||
|
@global_names << sclass_full_name
|
||||||
|
end
|
||||||
|
@global_graph << DOT::DOTEdge.new('from' => "#{sclass_full_name.gsub( /:/,'_' )}",
|
||||||
|
'to' => "#{cl.full_name.gsub( /:/, '_')}")
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
container.modules.each do |submod|
|
||||||
|
draw_module(submod, graph)
|
||||||
|
end
|
||||||
|
|
||||||
|
end
|
||||||
|
|
||||||
|
def convert_to_png(file_base, graph, name)
|
||||||
|
op_type = Options.instance.image_format
|
||||||
|
dotfile = File.join(DOT_PATH, file_base)
|
||||||
|
src = dotfile + ".dot"
|
||||||
|
dot = dotfile + "." + op_type
|
||||||
|
|
||||||
|
unless @options.quiet
|
||||||
|
$stderr.print "."
|
||||||
|
$stderr.flush
|
||||||
|
end
|
||||||
|
|
||||||
|
File.open(src, 'w+' ) do |f|
|
||||||
|
f << graph.to_s << "\n"
|
||||||
|
end
|
||||||
|
|
||||||
|
system "dot -T#{op_type} #{src} -o #{dot}"
|
||||||
|
|
||||||
|
# Now construct the imagemap wrapper around
|
||||||
|
# that png
|
||||||
|
|
||||||
|
return wrap_in_image_map(src, dot, name)
|
||||||
|
end
|
||||||
|
|
||||||
|
# Extract the client-side image map from dot, and use it
|
||||||
|
# to generate the imagemap proper. Return the whole
|
||||||
|
# <map>..<img> combination, suitable for inclusion on
|
||||||
|
# the page
|
||||||
|
|
||||||
|
def wrap_in_image_map(src, dot, name)
|
||||||
|
res = %{<map name="map">\n}
|
||||||
|
dot_map = `dot -Tismap #{src}`
|
||||||
|
dot_map.each do |area|
|
||||||
|
unless area =~ /^rectangle \((\d+),(\d+)\) \((\d+),(\d+)\) ([\/\w.]+)\s*(.*)/
|
||||||
|
$stderr.puts "Unexpected output from dot:\n#{area}"
|
||||||
|
return nil
|
||||||
|
end
|
||||||
|
|
||||||
|
blx = $1; bly = $2
|
||||||
|
trx = $3; try = $4
|
||||||
|
url = $5; area_name = $6
|
||||||
|
res << %{ <area shape="RECT" coords="#{blx},#{try},#{trx},#{bly}" }
|
||||||
|
res << %{ href="#{url}" alt="#{area_name}">\n}
|
||||||
|
end
|
||||||
|
res << "</map>\n"
|
||||||
|
# map_file = src.sub(/.dot/, '.map')
|
||||||
|
# system("dot -Timap #{src} -o #{map_file}")
|
||||||
|
res << %{<img src="#{dot}" usemap="#map" border=0 alt="#{name}">}
|
||||||
|
return res
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
112
lib/rdoc/generators/chm_generator.rb
Normal file
112
lib/rdoc/generators/chm_generator.rb
Normal file
|
|
@ -0,0 +1,112 @@
|
||||||
|
require 'rdoc/generators/html_generator'
|
||||||
|
|
||||||
|
module Generators
|
||||||
|
|
||||||
|
class CHMGenerator < HTMLGenerator
|
||||||
|
|
||||||
|
HHC_PATH = "c:\\Program Files\\HTML Help Workshop\\hhc.exe"
|
||||||
|
|
||||||
|
# Standard generator factory
|
||||||
|
def CHMGenerator.for(options)
|
||||||
|
CHMGenerator.new(options)
|
||||||
|
end
|
||||||
|
|
||||||
|
|
||||||
|
def initialize(*args)
|
||||||
|
super
|
||||||
|
@op_name = @options.op_name || "rdoc"
|
||||||
|
check_for_html_help_workshop
|
||||||
|
end
|
||||||
|
|
||||||
|
def check_for_html_help_workshop
|
||||||
|
stat = File.stat(HHC_PATH)
|
||||||
|
rescue
|
||||||
|
$stderr <<
|
||||||
|
"\n.chm output generation requires that Microsoft's Html Help\n" <<
|
||||||
|
"Workshop is installed. RDoc looks for it in:\n\n " <<
|
||||||
|
HHC_PATH <<
|
||||||
|
"\n\nYou can download a copy for free from:\n\n" <<
|
||||||
|
" http://msdn.microsoft.com/library/default.asp?" <<
|
||||||
|
"url=/library/en-us/htmlhelp/html/hwMicrosoftHTMLHelpDownloads.asp\n\n"
|
||||||
|
|
||||||
|
exit 99
|
||||||
|
end
|
||||||
|
|
||||||
|
# Generate the html as normal, then wrap it
|
||||||
|
# in a help project
|
||||||
|
def generate(info)
|
||||||
|
super
|
||||||
|
@project_name = @op_name + ".hhp"
|
||||||
|
create_help_project
|
||||||
|
end
|
||||||
|
|
||||||
|
# The project contains the project file, a table of contents
|
||||||
|
# and an index
|
||||||
|
def create_help_project
|
||||||
|
create_project_file
|
||||||
|
create_contents_and_index
|
||||||
|
compile_project
|
||||||
|
end
|
||||||
|
|
||||||
|
# The project file links together all the various
|
||||||
|
# files that go to make up the help.
|
||||||
|
|
||||||
|
def create_project_file
|
||||||
|
template = TemplatePage.new(RDoc::Page::HPP_FILE)
|
||||||
|
values = { "title" => @options.title, "opname" => @op_name }
|
||||||
|
files = []
|
||||||
|
@files.each do |f|
|
||||||
|
files << { "html_file_name" => f.path }
|
||||||
|
end
|
||||||
|
|
||||||
|
values['all_html_files'] = files
|
||||||
|
|
||||||
|
File.open(@project_name, "w") do |f|
|
||||||
|
template.write_html_on(f, values)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
# The contents is a list of all files and modules.
|
||||||
|
# For each we include as sub-entries the list
|
||||||
|
# of methods they contain. As we build the contents
|
||||||
|
# we also build an index file
|
||||||
|
|
||||||
|
def create_contents_and_index
|
||||||
|
contents = []
|
||||||
|
index = []
|
||||||
|
|
||||||
|
(@files+@classes).sort.each do |entry|
|
||||||
|
content_entry = { "c_name" => entry.name, "ref" => entry.path }
|
||||||
|
index << { "name" => entry.name, "aref" => entry.path }
|
||||||
|
|
||||||
|
internals = []
|
||||||
|
|
||||||
|
methods = entry.build_method_summary_list(entry.path)
|
||||||
|
|
||||||
|
content_entry["methods"] = methods unless methods.empty?
|
||||||
|
contents << content_entry
|
||||||
|
index.concat methods
|
||||||
|
end
|
||||||
|
|
||||||
|
values = { "contents" => contents }
|
||||||
|
template = TemplatePage.new(RDoc::Page::CONTENTS)
|
||||||
|
File.open("contents.hhc", "w") do |f|
|
||||||
|
template.write_html_on(f, values)
|
||||||
|
end
|
||||||
|
|
||||||
|
values = { "index" => index }
|
||||||
|
template = TemplatePage.new(RDoc::Page::CHM_INDEX)
|
||||||
|
File.open("index.hhk", "w") do |f|
|
||||||
|
template.write_html_on(f, values)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
# Invoke the windows help compiler to compiler the project
|
||||||
|
def compile_project
|
||||||
|
system("\"#{HHC_PATH}\" #@project_name")
|
||||||
|
end
|
||||||
|
|
||||||
|
end
|
||||||
|
|
||||||
|
|
||||||
|
end
|
||||||
1370
lib/rdoc/generators/html_generator.rb
Normal file
1370
lib/rdoc/generators/html_generator.rb
Normal file
File diff suppressed because it is too large
Load diff
86
lib/rdoc/generators/template/chm/chm.rb
Normal file
86
lib/rdoc/generators/template/chm/chm.rb
Normal file
|
|
@ -0,0 +1,86 @@
|
||||||
|
module RDoc
|
||||||
|
module Page
|
||||||
|
|
||||||
|
require "rdoc/generators/template/html/html"
|
||||||
|
|
||||||
|
# This is a nasty little hack, but hhc doesn't support the <?xml
|
||||||
|
# tag, so...
|
||||||
|
|
||||||
|
BODY.sub!(/<\?xml.*\?>/, '')
|
||||||
|
|
||||||
|
HPP_FILE = %{
|
||||||
|
[OPTIONS]
|
||||||
|
Auto Index = Yes
|
||||||
|
Compatibility=1.1 or later
|
||||||
|
Compiled file=%opname%.chm
|
||||||
|
Contents file=contents.hhc
|
||||||
|
Full-text search=Yes
|
||||||
|
Index file=index.hhk
|
||||||
|
Language=0x409 English(United States)
|
||||||
|
Title=%title%
|
||||||
|
|
||||||
|
[FILES]
|
||||||
|
START:all_html_files
|
||||||
|
%html_file_name%
|
||||||
|
END:all_html_files
|
||||||
|
}
|
||||||
|
|
||||||
|
CONTENTS = %{
|
||||||
|
<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
|
||||||
|
<HTML>
|
||||||
|
<HEAD>
|
||||||
|
<meta name="GENERATOR" content="Microsoft® HTML Help Workshop 4.1">
|
||||||
|
<!-- Sitemap 1.0 -->
|
||||||
|
</HEAD><BODY>
|
||||||
|
<OBJECT type="text/site properties">
|
||||||
|
<param name="Foreground" value="0x80">
|
||||||
|
<param name="Window Styles" value="0x800025">
|
||||||
|
<param name="ImageType" value="Folder">
|
||||||
|
</OBJECT>
|
||||||
|
<UL>
|
||||||
|
START:contents
|
||||||
|
<LI> <OBJECT type="text/sitemap">
|
||||||
|
<param name="Name" value="%c_name%">
|
||||||
|
<param name="Local" value="%ref%">
|
||||||
|
</OBJECT>
|
||||||
|
IF:methods
|
||||||
|
<ul>
|
||||||
|
START:methods
|
||||||
|
<LI> <OBJECT type="text/sitemap">
|
||||||
|
<param name="Name" value="%name%">
|
||||||
|
<param name="Local" value="%aref%">
|
||||||
|
</OBJECT>
|
||||||
|
END:methods
|
||||||
|
</ul>
|
||||||
|
ENDIF:methods
|
||||||
|
</LI>
|
||||||
|
END:contents
|
||||||
|
</UL>
|
||||||
|
</BODY></HTML>
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
CHM_INDEX = %{
|
||||||
|
<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
|
||||||
|
<HTML>
|
||||||
|
<HEAD>
|
||||||
|
<meta name="GENERATOR" content="Microsoft® HTML Help Workshop 4.1">
|
||||||
|
<!-- Sitemap 1.0 -->
|
||||||
|
</HEAD><BODY>
|
||||||
|
<OBJECT type="text/site properties">
|
||||||
|
<param name="Foreground" value="0x80">
|
||||||
|
<param name="Window Styles" value="0x800025">
|
||||||
|
<param name="ImageType" value="Folder">
|
||||||
|
</OBJECT>
|
||||||
|
<UL>
|
||||||
|
START:index
|
||||||
|
<LI> <OBJECT type="text/sitemap">
|
||||||
|
<param name="Name" value="%name%">
|
||||||
|
<param name="Local" value="%aref%">
|
||||||
|
</OBJECT>
|
||||||
|
END:index
|
||||||
|
</UL>
|
||||||
|
</BODY></HTML>
|
||||||
|
}
|
||||||
|
end
|
||||||
|
end
|
||||||
631
lib/rdoc/generators/template/html/css2.rb
Normal file
631
lib/rdoc/generators/template/html/css2.rb
Normal file
|
|
@ -0,0 +1,631 @@
|
||||||
|
#
|
||||||
|
# = CSS2 RDoc HTML template
|
||||||
|
#
|
||||||
|
# This is a template for RDoc that uses XHTML 1.0 Transitional and dictates a
|
||||||
|
# bit more of the appearance of the output to cascading stylesheets than the
|
||||||
|
# default. It was designed for clean inline code display, and uses DHTMl to
|
||||||
|
# toggle the visbility of each method's source with each click on the '[source]'
|
||||||
|
# link.
|
||||||
|
#
|
||||||
|
# == Authors
|
||||||
|
#
|
||||||
|
# * Michael Granger <ged@FaerieMUD.org>
|
||||||
|
#
|
||||||
|
# Copyright (c) 2002, 2003 The FaerieMUD Consortium. Some rights reserved.
|
||||||
|
#
|
||||||
|
# This work is licensed under the Creative Commons Attribution License. To view
|
||||||
|
# a copy of this license, visit http://creativecommons.org/licenses/by/1.0/ or
|
||||||
|
# send a letter to Creative Commons, 559 Nathan Abbott Way, Stanford, California
|
||||||
|
# 94305, USA.
|
||||||
|
#
|
||||||
|
|
||||||
|
module RDoc
|
||||||
|
module Page
|
||||||
|
|
||||||
|
FONTS = "Verdana,Arial,Helvetica,sans-serif"
|
||||||
|
|
||||||
|
STYLE = %{
|
||||||
|
body {
|
||||||
|
margin: 0;
|
||||||
|
padding: 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
h1,h2,h3,h4 { margin: 0; color: #efefef; background: transparent; }
|
||||||
|
h1 { font-size: 120%; }
|
||||||
|
h2,h3,h4 { margin-top: 1em; }
|
||||||
|
|
||||||
|
a { background: #eef; color: #039; text-decoration: none; }
|
||||||
|
a:hover { background: #039; color: #eef; }
|
||||||
|
|
||||||
|
/* Override the base stylesheet's Anchor inside a table cell */
|
||||||
|
td > a {
|
||||||
|
background: transparent;
|
||||||
|
color: #039;
|
||||||
|
text-decoration: none;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* === Structural elements =================================== */
|
||||||
|
|
||||||
|
div#index {
|
||||||
|
margin: 0;
|
||||||
|
padding: 0;
|
||||||
|
font-size: 0.9em;
|
||||||
|
}
|
||||||
|
|
||||||
|
div#index a {
|
||||||
|
margin-left: 0.7em;
|
||||||
|
}
|
||||||
|
|
||||||
|
div#classHeader {
|
||||||
|
width: auto;
|
||||||
|
background: #039;
|
||||||
|
color: white;
|
||||||
|
padding: 0.5em 1.5em 0.5em 1.5em;
|
||||||
|
margin: 0;
|
||||||
|
border-bottom: 3px solid #006;
|
||||||
|
}
|
||||||
|
|
||||||
|
div#classHeader a {
|
||||||
|
background: inherit;
|
||||||
|
color: white;
|
||||||
|
}
|
||||||
|
|
||||||
|
div#classHeader td {
|
||||||
|
background: inherit;
|
||||||
|
color: white;
|
||||||
|
}
|
||||||
|
|
||||||
|
div#fileHeader {
|
||||||
|
width: auto;
|
||||||
|
background: #039;
|
||||||
|
color: white;
|
||||||
|
padding: 0.5em 1.5em 0.5em 1.5em;
|
||||||
|
margin: 0;
|
||||||
|
border-bottom: 3px solid #006;
|
||||||
|
}
|
||||||
|
|
||||||
|
div#fileHeader a {
|
||||||
|
background: inherit;
|
||||||
|
color: white;
|
||||||
|
}
|
||||||
|
|
||||||
|
div#fileHeader td {
|
||||||
|
background: inherit;
|
||||||
|
color: white;
|
||||||
|
}
|
||||||
|
|
||||||
|
div#bodyContent {
|
||||||
|
padding: 0 1.5em 0 1.5em;
|
||||||
|
}
|
||||||
|
|
||||||
|
div#description {
|
||||||
|
padding: 0.5em 1.5em;
|
||||||
|
background: #efefef;
|
||||||
|
border: 1px dotted #999;
|
||||||
|
}
|
||||||
|
|
||||||
|
div#description h1,h2,h3,h4,h5,h6 {
|
||||||
|
color: black;
|
||||||
|
background: transparent;
|
||||||
|
}
|
||||||
|
|
||||||
|
div#validator-badges {
|
||||||
|
text-align: center;
|
||||||
|
}
|
||||||
|
div#validator-badges img { border: 0; }
|
||||||
|
|
||||||
|
div#copyright {
|
||||||
|
color: #333;
|
||||||
|
background: #efefef;
|
||||||
|
font: 0.75em sans-serif;
|
||||||
|
margin-top: 5em;
|
||||||
|
margin-bottom: 0;
|
||||||
|
padding: 0.5em 2em;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* === Classes =================================== */
|
||||||
|
|
||||||
|
table.header-table {
|
||||||
|
color: white;
|
||||||
|
font-size: small;
|
||||||
|
}
|
||||||
|
|
||||||
|
.type-note {
|
||||||
|
font-size: small;
|
||||||
|
color: #DEDEDE;
|
||||||
|
}
|
||||||
|
|
||||||
|
.section-bar {
|
||||||
|
background: #eee;
|
||||||
|
color: #333;
|
||||||
|
padding: 3px;
|
||||||
|
border: 1px solid #999;
|
||||||
|
}
|
||||||
|
|
||||||
|
.top-aligned-row { vertical-align: vertical-align: top }
|
||||||
|
|
||||||
|
/* --- Context section classes ----------------------- */
|
||||||
|
|
||||||
|
.context-row { }
|
||||||
|
.context-item-name { font-family: monospace; font-weight: bold; color: black; }
|
||||||
|
.context-item-value { font-size: x-small; color: #448; }
|
||||||
|
.context-item-desc { background: #efefef; }
|
||||||
|
|
||||||
|
/* --- Method classes -------------------------- */
|
||||||
|
.method-detail {
|
||||||
|
background: #EFEFEF;
|
||||||
|
padding: 0;
|
||||||
|
margin-top: 0.5em;
|
||||||
|
margin-bottom: 0.5em;
|
||||||
|
border: 1px dotted #DDD;
|
||||||
|
}
|
||||||
|
.method-heading {
|
||||||
|
color: black;
|
||||||
|
background: #AAA;
|
||||||
|
border-bottom: 1px solid #666;
|
||||||
|
padding: 0.2em 0.5em 0 0.5em;
|
||||||
|
}
|
||||||
|
.method-signature { color: black; background: inherit; }
|
||||||
|
.method-name { font-weight: bold; }
|
||||||
|
.method-args { font-style: italic; }
|
||||||
|
.method-description { padding: 0 0.5em 0 0.5em; }
|
||||||
|
|
||||||
|
/* --- Source code sections -------------------- */
|
||||||
|
|
||||||
|
a.source-toggle { font-size: 90%; }
|
||||||
|
div.method-source-code {
|
||||||
|
background: #262626;
|
||||||
|
color: #ffdead;
|
||||||
|
margin: 1em;
|
||||||
|
padding: 0.5em;
|
||||||
|
border: 1px dashed #999;
|
||||||
|
overflow: hidden;
|
||||||
|
}
|
||||||
|
|
||||||
|
div.method-source-code pre { color: #ffdead; overflow: hidden; }
|
||||||
|
|
||||||
|
/* --- Ruby keyword styles --------------------- */
|
||||||
|
/* (requires a hacked html_generator.rb to add more class-types) */
|
||||||
|
.ruby-constant { color: #7fffd4; background: transparent; }
|
||||||
|
.ruby-keyword { color: #00ffff; background: transparent; }
|
||||||
|
.ruby-ivar { color: #eedd82; background: transparent; }
|
||||||
|
.ruby-operator { color: #00ffee; background: transparent; }
|
||||||
|
.ruby-identifier { color: #ffdead; background: transparent; }
|
||||||
|
.ruby-node { color: #ffa07a; background: transparent; }
|
||||||
|
.ruby-comment { color: #b22222; font-weight: bold; background: transparent; }
|
||||||
|
.ruby-regexp { color: #ffa07a; background: transparent; }
|
||||||
|
.ruby-value { color: #7fffd4; background: transparent; }
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#####################################################################
|
||||||
|
### H E A D E R T E M P L A T E
|
||||||
|
#####################################################################
|
||||||
|
|
||||||
|
XHTML_PREAMBLE = %{<?xml version="1.0" encoding="%charset%"?>
|
||||||
|
<!DOCTYPE html
|
||||||
|
PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
|
||||||
|
"DTD/xhtml1-transitional.dtd">
|
||||||
|
}
|
||||||
|
|
||||||
|
HEADER = XHTML_PREAMBLE + %{
|
||||||
|
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
|
||||||
|
<head>
|
||||||
|
<title>%title%</title>
|
||||||
|
<meta http-equiv="Content-Type" content="text/html; charset=%charset%" />
|
||||||
|
<meta http-equiv="Content-Script-Type" content="text/javascript" />
|
||||||
|
<link rel="stylesheet" href="%style_url%" type="text/css" media="screen" />
|
||||||
|
<script type="text/javascript">
|
||||||
|
// <![CDATA[
|
||||||
|
|
||||||
|
function popupCode( url ) {
|
||||||
|
window.open(url, "Code", "resizable=yes,scrollbars=yes,toolbar=no,status=no,height=150,width=400")
|
||||||
|
}
|
||||||
|
|
||||||
|
function toggleCode( id ) {
|
||||||
|
if ( document.getElementById )
|
||||||
|
elem = document.getElementById( id );
|
||||||
|
else if ( document.all )
|
||||||
|
elem = eval( "document.all." + id );
|
||||||
|
else
|
||||||
|
return false;
|
||||||
|
|
||||||
|
elemStyle = elem.style;
|
||||||
|
|
||||||
|
if ( elemStyle.display != "block" ) {
|
||||||
|
elemStyle.display = "block"
|
||||||
|
} else {
|
||||||
|
elemStyle.display = "none"
|
||||||
|
}
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Make codeblocks hidden by default
|
||||||
|
document.writeln( "<style type=\\"text/css\\">div.method-source-code { display: none }</style>" )
|
||||||
|
|
||||||
|
// ]]>
|
||||||
|
</script>
|
||||||
|
|
||||||
|
</head>
|
||||||
|
<body>
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#####################################################################
|
||||||
|
### C O N T E X T C O N T E N T T E M P L A T E
|
||||||
|
#####################################################################
|
||||||
|
|
||||||
|
CONTEXT_CONTENT = %{
|
||||||
|
<div id="contextContent">
|
||||||
|
IF:diagram
|
||||||
|
<div id="diagram">
|
||||||
|
%diagram%
|
||||||
|
</div>
|
||||||
|
ENDIF:diagram
|
||||||
|
|
||||||
|
IF:description
|
||||||
|
<div id="description">
|
||||||
|
%description%
|
||||||
|
</div>
|
||||||
|
ENDIF:description
|
||||||
|
|
||||||
|
IF:requires
|
||||||
|
<div id="requires-list">
|
||||||
|
<h2 class="section-bar">Required files</h2>
|
||||||
|
|
||||||
|
<div class="name-list">
|
||||||
|
START:requires
|
||||||
|
HREF:aref:name:
|
||||||
|
END:requires
|
||||||
|
</div>
|
||||||
|
</div>
|
||||||
|
ENDIF:requires
|
||||||
|
|
||||||
|
IF:methods
|
||||||
|
<div id="method-list">
|
||||||
|
<h2 class="section-bar">Methods</h2>
|
||||||
|
|
||||||
|
<div class="name-list">
|
||||||
|
START:methods
|
||||||
|
HREF:aref:name:
|
||||||
|
END:methods
|
||||||
|
</div>
|
||||||
|
</div>
|
||||||
|
ENDIF:methods
|
||||||
|
|
||||||
|
IF:constants
|
||||||
|
<div id="constants-list">
|
||||||
|
<h2 class="section-bar">Constants</h2>
|
||||||
|
|
||||||
|
<div class="name-list">
|
||||||
|
<table summary="Constants">
|
||||||
|
START:constants
|
||||||
|
<tr class="top-aligned-row context-row">
|
||||||
|
<td class="context-item-name">%name%</td>
|
||||||
|
<td>=</td>
|
||||||
|
<td class="context-item-value">%value%</td>
|
||||||
|
</tr>
|
||||||
|
IF:desc
|
||||||
|
<tr class="top-aligned-row context-row">
|
||||||
|
<td> </td>
|
||||||
|
<td colspan="2" class="context-item-desc">%desc%</td>
|
||||||
|
</tr>
|
||||||
|
ENDIF:desc
|
||||||
|
END:constants
|
||||||
|
</table>
|
||||||
|
</div>
|
||||||
|
</div>
|
||||||
|
ENDIF:constants
|
||||||
|
|
||||||
|
IF:aliases
|
||||||
|
<div id="aliases-list">
|
||||||
|
<h2 class="section-bar">External Aliases</h2>
|
||||||
|
|
||||||
|
<div class="name-list">
|
||||||
|
START:aliases
|
||||||
|
%old_name% -> %new_name% <br />
|
||||||
|
END:aliases
|
||||||
|
</div>
|
||||||
|
</div>
|
||||||
|
ENDIF:aliases
|
||||||
|
|
||||||
|
|
||||||
|
IF:attributes
|
||||||
|
<div id="attribute-list">
|
||||||
|
<h2 class="section-bar">Attributes</h2>
|
||||||
|
|
||||||
|
<div class="name-list">
|
||||||
|
<table>
|
||||||
|
START:attributes
|
||||||
|
<tr class="top-aligned-row context-row">
|
||||||
|
<td class="context-item-name">%name%</td>
|
||||||
|
<td class="context-item-value"> [%rw%] </td>
|
||||||
|
<td class="context-item-desc">%a_desc%</td>
|
||||||
|
</tr>
|
||||||
|
END:attributes
|
||||||
|
</table>
|
||||||
|
</div>
|
||||||
|
</div>
|
||||||
|
ENDIF:attributes
|
||||||
|
|
||||||
|
IF:classlist
|
||||||
|
<div id="class-list">
|
||||||
|
<h2 class="section-bar">Classes and Modules</h2>
|
||||||
|
|
||||||
|
%classlist%
|
||||||
|
</div>
|
||||||
|
ENDIF:classlist
|
||||||
|
|
||||||
|
</div>
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#####################################################################
|
||||||
|
### F O O T E R T E M P L A T E
|
||||||
|
#####################################################################
|
||||||
|
FOOTER = %{
|
||||||
|
<div id="validator-badges">
|
||||||
|
<p><small><a href="http://validator.w3.org/check/referer">[Validate]</a></small></p>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
</body>
|
||||||
|
</html>
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#####################################################################
|
||||||
|
### F I L E P A G E H E A D E R T E M P L A T E
|
||||||
|
#####################################################################
|
||||||
|
|
||||||
|
FILE_PAGE = %{
|
||||||
|
<div id="fileHeader">
|
||||||
|
<h1>%short_name%</h1>
|
||||||
|
<table class="header-table">
|
||||||
|
<tr class="top-aligned-row">
|
||||||
|
<td><strong>Path:</strong></td>
|
||||||
|
<td>%full_path%
|
||||||
|
IF:cvsurl
|
||||||
|
(<a href="%cvsurl%">CVS</a>)
|
||||||
|
ENDIF:cvsurl
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr class="top-aligned-row">
|
||||||
|
<td><strong>Last Update:</strong></td>
|
||||||
|
<td>%dtm_modified%</td>
|
||||||
|
</tr>
|
||||||
|
</table>
|
||||||
|
</div>
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#####################################################################
|
||||||
|
### C L A S S P A G E H E A D E R T E M P L A T E
|
||||||
|
#####################################################################
|
||||||
|
|
||||||
|
CLASS_PAGE = %{
|
||||||
|
<div id="classHeader">
|
||||||
|
<h1>%full_name% <sup class="type-note">(%classmod%)</sup></h1>
|
||||||
|
<table class="header-table">
|
||||||
|
<tr class="top-aligned-row">
|
||||||
|
<td><strong>In:</strong></td>
|
||||||
|
<td>
|
||||||
|
START:infiles
|
||||||
|
IF:full_path_url
|
||||||
|
<a href="%full_path_url%">
|
||||||
|
ENDIF:full_path_url
|
||||||
|
%full_path%
|
||||||
|
IF:full_path_url
|
||||||
|
</a>
|
||||||
|
ENDIF:full_path_url
|
||||||
|
IF:cvsurl
|
||||||
|
(<a href="%cvsurl%">CVS</a>)
|
||||||
|
ENDIF:cvsurl
|
||||||
|
<br />
|
||||||
|
END:infiles
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
|
||||||
|
IF:parent
|
||||||
|
<tr class="top-aligned-row">
|
||||||
|
<td><strong>Parent:</strong></td>
|
||||||
|
<td>
|
||||||
|
IF:par_url
|
||||||
|
<a href="%par_url%">
|
||||||
|
ENDIF:par_url
|
||||||
|
%parent%
|
||||||
|
IF:par_url
|
||||||
|
</a>
|
||||||
|
ENDIF:par_url
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
ENDIF:parent
|
||||||
|
</table>
|
||||||
|
</div>
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#####################################################################
|
||||||
|
### M E T H O D L I S T T E M P L A T E
|
||||||
|
#####################################################################
|
||||||
|
|
||||||
|
METHOD_LIST = %{
|
||||||
|
|
||||||
|
<!-- if includes -->
|
||||||
|
IF:includes
|
||||||
|
<div id="includes">
|
||||||
|
<h2 class="section-bar">Included Modules</h2>
|
||||||
|
|
||||||
|
<div id="includes-list">
|
||||||
|
START:includes
|
||||||
|
<span class="include-name">HREF:aref:name:</span>
|
||||||
|
END:includes
|
||||||
|
</div>
|
||||||
|
</div>
|
||||||
|
ENDIF:includes
|
||||||
|
|
||||||
|
|
||||||
|
<!-- if method_list -->
|
||||||
|
IF:method_list
|
||||||
|
<div id="methods">
|
||||||
|
START:method_list
|
||||||
|
IF:methods
|
||||||
|
<h2 class="section-bar">%type% %category% methods</h2>
|
||||||
|
|
||||||
|
START:methods
|
||||||
|
<!-- %name%%params% -->
|
||||||
|
<div id="method-%aref%" class="method-detail">
|
||||||
|
<a name="%aref%"></a>
|
||||||
|
|
||||||
|
<div class="method-heading">
|
||||||
|
IF:codeurl
|
||||||
|
<a href="%codeurl%" target="Code" class="method-signature"
|
||||||
|
onclick="popupCode('%codeurl%');return false;">
|
||||||
|
ENDIF:codeurl
|
||||||
|
IF:sourcecode
|
||||||
|
<a href="#%aref%" class="method-signature">
|
||||||
|
ENDIF:sourcecode
|
||||||
|
<span class="method-name">%name%</span><span class="method-args">%params%</span>
|
||||||
|
IF:codeurl
|
||||||
|
</a>
|
||||||
|
ENDIF:codeurl
|
||||||
|
IF:sourcecode
|
||||||
|
</a>
|
||||||
|
ENDIF:sourcecode
|
||||||
|
</div>
|
||||||
|
|
||||||
|
<div class="method-description">
|
||||||
|
IF:m_desc
|
||||||
|
%m_desc%
|
||||||
|
ENDIF:m_desc
|
||||||
|
IF:sourcecode
|
||||||
|
<p><a class="source-toggle" href="#"
|
||||||
|
onclick="toggleCode('%aref%-source');return false;">[Source]</a></p>
|
||||||
|
<div class="method-source-code" id="%aref%-source">
|
||||||
|
<pre>
|
||||||
|
%sourcecode%
|
||||||
|
</pre>
|
||||||
|
</div>
|
||||||
|
ENDIF:sourcecode
|
||||||
|
</div>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
END:methods
|
||||||
|
ENDIF:methods
|
||||||
|
END:method_list
|
||||||
|
|
||||||
|
</div>
|
||||||
|
ENDIF:method_list
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#####################################################################
|
||||||
|
### B O D Y T E M P L A T E
|
||||||
|
#####################################################################
|
||||||
|
|
||||||
|
BODY = HEADER + %{
|
||||||
|
|
||||||
|
!INCLUDE! <!-- banner header -->
|
||||||
|
|
||||||
|
<div id="bodyContent">
|
||||||
|
|
||||||
|
} + CONTEXT_CONTENT + METHOD_LIST + %{
|
||||||
|
|
||||||
|
</div>
|
||||||
|
|
||||||
|
} + FOOTER
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
#####################################################################
|
||||||
|
### S O U R C E C O D E T E M P L A T E
|
||||||
|
#####################################################################
|
||||||
|
|
||||||
|
SRC_PAGE = XHTML_PREAMBLE + %{
|
||||||
|
<!--
|
||||||
|
|
||||||
|
%title%
|
||||||
|
|
||||||
|
-->
|
||||||
|
<html>
|
||||||
|
<head>
|
||||||
|
<title>%title%</title>
|
||||||
|
<meta http-equiv="Content-Type" content="text/html; charset=%charset%" />
|
||||||
|
<link rel="stylesheet" href="http://www.FaerieMUD.org/stylesheets/rdoc.css" type="text/css" />
|
||||||
|
</head>
|
||||||
|
<body>
|
||||||
|
<pre>%code%</pre>
|
||||||
|
</body>
|
||||||
|
</html>
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#####################################################################
|
||||||
|
### I N D E X F I L E T E M P L A T E S
|
||||||
|
#####################################################################
|
||||||
|
|
||||||
|
FR_INDEX_BODY = %{
|
||||||
|
!INCLUDE!
|
||||||
|
}
|
||||||
|
|
||||||
|
FILE_INDEX = XHTML_PREAMBLE + %{
|
||||||
|
<!--
|
||||||
|
|
||||||
|
%list_title%
|
||||||
|
|
||||||
|
-->
|
||||||
|
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
|
||||||
|
<head>
|
||||||
|
<title>%list_title%</title>
|
||||||
|
<meta http-equiv="Content-Type" content="text/html; charset=%charset%" />
|
||||||
|
<link rel="stylesheet" href="%style_url%" type="text/css" />
|
||||||
|
<base target="docwin" />
|
||||||
|
</head>
|
||||||
|
<body>
|
||||||
|
<div id="index">
|
||||||
|
<h1 class="section-bar">%list_title%</h1>
|
||||||
|
<div id="index-entries">
|
||||||
|
START:entries
|
||||||
|
<a href="%href%">%name%</a><br />
|
||||||
|
END:entries
|
||||||
|
</div>
|
||||||
|
</div>
|
||||||
|
</body>
|
||||||
|
</html>
|
||||||
|
}
|
||||||
|
|
||||||
|
CLASS_INDEX = FILE_INDEX
|
||||||
|
METHOD_INDEX = FILE_INDEX
|
||||||
|
|
||||||
|
INDEX = %{<?xml version="1.0" encoding="%charset%"?>
|
||||||
|
<!DOCTYPE html
|
||||||
|
PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN"
|
||||||
|
"DTD/xhtml1-frameset.dtd">
|
||||||
|
|
||||||
|
<!--
|
||||||
|
|
||||||
|
%title%
|
||||||
|
|
||||||
|
-->
|
||||||
|
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
|
||||||
|
<head>
|
||||||
|
<title>%title%</title>
|
||||||
|
<meta http-equiv="Content-Type" content="text/html; charset=%charset%" />
|
||||||
|
</head>
|
||||||
|
<frameset rows="20%, 80%">
|
||||||
|
<frameset cols="25%,35%,45%">
|
||||||
|
<frame src="fr_file_index.html" title="Files" name="Files" />
|
||||||
|
<frame src="fr_class_index.html" name="Classes" />
|
||||||
|
<frame src="fr_method_index.html" name="Methods" />
|
||||||
|
</frameset>
|
||||||
|
<frame src="%initial_page%" name="docwin" />
|
||||||
|
</frameset>
|
||||||
|
</html>
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
end # module Page
|
||||||
|
end # class RDoc
|
||||||
|
|
||||||
418
lib/rdoc/generators/template/html/hefss.rb
Normal file
418
lib/rdoc/generators/template/html/hefss.rb
Normal file
|
|
@ -0,0 +1,418 @@
|
||||||
|
module RDoc
|
||||||
|
module Page
|
||||||
|
|
||||||
|
|
||||||
|
FONTS = "Verdana, Arial, Helvetica, sans-serif"
|
||||||
|
|
||||||
|
STYLE = %{
|
||||||
|
body,p { font-family: Verdana, Arial, Helvetica, sans-serif;
|
||||||
|
color: #000040; background: #BBBBBB;
|
||||||
|
}
|
||||||
|
|
||||||
|
td { font-family: Verdana, Arial, Helvetica, sans-serif;
|
||||||
|
color: #000040;
|
||||||
|
}
|
||||||
|
|
||||||
|
.attr-rw { font-size: small; color: #444488 }
|
||||||
|
|
||||||
|
.title-row {color: #eeeeff;
|
||||||
|
background: #BBBBDD;
|
||||||
|
}
|
||||||
|
|
||||||
|
.big-title-font { color: white;
|
||||||
|
font-family: Verdana, Arial, Helvetica, sans-serif;
|
||||||
|
font-size: large;
|
||||||
|
height: 50px}
|
||||||
|
|
||||||
|
.small-title-font { color: purple;
|
||||||
|
font-family: Verdana, Arial, Helvetica, sans-serif;
|
||||||
|
font-size: small; }
|
||||||
|
|
||||||
|
.aqua { color: purple }
|
||||||
|
|
||||||
|
.method-name, attr-name {
|
||||||
|
font-family: monospace; font-weight: bold;
|
||||||
|
}
|
||||||
|
|
||||||
|
.tablesubtitle {
|
||||||
|
width: 100%;
|
||||||
|
margin-top: 1ex;
|
||||||
|
margin-bottom: .5ex;
|
||||||
|
padding: 5px 0px 5px 20px;
|
||||||
|
font-size: large;
|
||||||
|
color: purple;
|
||||||
|
background: #BBBBCC;
|
||||||
|
}
|
||||||
|
|
||||||
|
.tablesubsubtitle {
|
||||||
|
width: 100%;
|
||||||
|
margin-top: 1ex;
|
||||||
|
margin-bottom: .5ex;
|
||||||
|
padding: 5px 0px 5px 20px;
|
||||||
|
font-size: medium;
|
||||||
|
color: white;
|
||||||
|
background: #BBBBCC;
|
||||||
|
}
|
||||||
|
|
||||||
|
.name-list {
|
||||||
|
font-family: monospace;
|
||||||
|
margin-left: 40px;
|
||||||
|
margin-bottom: 2ex;
|
||||||
|
line-height: 140%;
|
||||||
|
}
|
||||||
|
|
||||||
|
.description {
|
||||||
|
margin-left: 40px;
|
||||||
|
margin-bottom: 2ex;
|
||||||
|
line-height: 140%;
|
||||||
|
}
|
||||||
|
|
||||||
|
.methodtitle {
|
||||||
|
font-size: medium;
|
||||||
|
text_decoration: none;
|
||||||
|
padding: 3px 3px 3px 20px;
|
||||||
|
color: #0000AA;
|
||||||
|
}
|
||||||
|
|
||||||
|
.column-title {
|
||||||
|
font-size: medium;
|
||||||
|
font-weight: bold;
|
||||||
|
text_decoration: none;
|
||||||
|
padding: 3px 3px 3px 20px;
|
||||||
|
color: #3333CC;
|
||||||
|
}
|
||||||
|
|
||||||
|
.variable-name {
|
||||||
|
font-family: monospace;
|
||||||
|
font-size: medium;
|
||||||
|
text_decoration: none;
|
||||||
|
padding: 3px 3px 3px 20px;
|
||||||
|
color: #0000AA;
|
||||||
|
}
|
||||||
|
|
||||||
|
.row-name {
|
||||||
|
font-size: medium;
|
||||||
|
font-weight: medium;
|
||||||
|
font-family: monospace;
|
||||||
|
text_decoration: none;
|
||||||
|
padding: 3px 3px 3px 20px;
|
||||||
|
}
|
||||||
|
|
||||||
|
.paramsig {
|
||||||
|
font-size: small;
|
||||||
|
}
|
||||||
|
|
||||||
|
.srcbut { float: right }
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
############################################################################
|
||||||
|
|
||||||
|
|
||||||
|
BODY = %{
|
||||||
|
<html><head>
|
||||||
|
<title>%title%</title>
|
||||||
|
<meta http-equiv="Content-Type" content="text/html; charset=%charset%">
|
||||||
|
<link rel=StyleSheet href="%style_url%" type="text/css" media=screen>
|
||||||
|
<script type="text/javascript" language="JavaScript">
|
||||||
|
<!--
|
||||||
|
function popCode(url) {
|
||||||
|
parent.frames.source.location = url
|
||||||
|
}
|
||||||
|
//-->
|
||||||
|
</script>
|
||||||
|
</head>
|
||||||
|
<body bgcolor="#BBBBBB">
|
||||||
|
|
||||||
|
!INCLUDE! <!-- banner header -->
|
||||||
|
|
||||||
|
IF:diagram
|
||||||
|
<table width="100%"><tr><td align="center">
|
||||||
|
%diagram%
|
||||||
|
</td></tr></table>
|
||||||
|
ENDIF:diagram
|
||||||
|
|
||||||
|
IF:description
|
||||||
|
<div class="description">%description%</div>
|
||||||
|
ENDIF:description
|
||||||
|
|
||||||
|
IF:requires
|
||||||
|
<table cellpadding=5 width="100%">
|
||||||
|
<tr><td class="tablesubtitle">Required files</td></tr>
|
||||||
|
</table><br>
|
||||||
|
<div class="name-list">
|
||||||
|
START:requires
|
||||||
|
HREF:aref:name:
|
||||||
|
END:requires
|
||||||
|
ENDIF:requires
|
||||||
|
</div>
|
||||||
|
|
||||||
|
IF:methods
|
||||||
|
<table cellpadding=5 width="100%">
|
||||||
|
<tr><td class="tablesubtitle">Subroutines and Functions</td></tr>
|
||||||
|
</table><br>
|
||||||
|
<div class="name-list">
|
||||||
|
START:methods
|
||||||
|
HREF:aref:name:,
|
||||||
|
END:methods
|
||||||
|
</div>
|
||||||
|
ENDIF:methods
|
||||||
|
|
||||||
|
IF:attributes
|
||||||
|
<table cellpadding=5 width="100%">
|
||||||
|
<tr><td class="tablesubtitle">Arguments</td></tr>
|
||||||
|
</table><br>
|
||||||
|
<table cellspacing=5>
|
||||||
|
START:attributes
|
||||||
|
<tr valign="top">
|
||||||
|
IF:rw
|
||||||
|
<td align="center" class="attr-rw"> [%rw%] </td>
|
||||||
|
ENDIF:rw
|
||||||
|
IFNOT:rw
|
||||||
|
<td></td>
|
||||||
|
ENDIF:rw
|
||||||
|
<td class="attr-name">%name%</td>
|
||||||
|
<td>%a_desc%</td>
|
||||||
|
</tr>
|
||||||
|
END:attributes
|
||||||
|
</table>
|
||||||
|
ENDIF:attributes
|
||||||
|
|
||||||
|
IF:classlist
|
||||||
|
<table cellpadding=5 width="100%">
|
||||||
|
<tr><td class="tablesubtitle">Modules</td></tr>
|
||||||
|
</table><br>
|
||||||
|
%classlist%<br>
|
||||||
|
ENDIF:classlist
|
||||||
|
|
||||||
|
!INCLUDE! <!-- method descriptions -->
|
||||||
|
|
||||||
|
</body>
|
||||||
|
</html>
|
||||||
|
}
|
||||||
|
|
||||||
|
###############################################################################
|
||||||
|
|
||||||
|
FILE_PAGE = <<_FILE_PAGE_
|
||||||
|
<table width="100%">
|
||||||
|
<tr class="title-row">
|
||||||
|
<td><table width="100%"><tr>
|
||||||
|
<td class="big-title-font" colspan=2><font size=-3><B>File</B><BR></font>%short_name%</td>
|
||||||
|
<td align="right"><table cellspacing=0 cellpadding=2>
|
||||||
|
<tr>
|
||||||
|
<td class="small-title-font">Path:</td>
|
||||||
|
<td class="small-title-font">%full_path%
|
||||||
|
IF:cvsurl
|
||||||
|
(<a href="%cvsurl%">CVS</a>)
|
||||||
|
ENDIF:cvsurl
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td class="small-title-font">Modified:</td>
|
||||||
|
<td class="small-title-font">%dtm_modified%</td>
|
||||||
|
</tr>
|
||||||
|
</table>
|
||||||
|
</td></tr></table></td>
|
||||||
|
</tr>
|
||||||
|
</table><br>
|
||||||
|
_FILE_PAGE_
|
||||||
|
|
||||||
|
###################################################################
|
||||||
|
|
||||||
|
CLASS_PAGE = %{
|
||||||
|
<table width="100%" border=0 cellspacing=0>
|
||||||
|
<tr class="title-row">
|
||||||
|
<td class="big-title-font">
|
||||||
|
<font size=-3><B>%classmod%</B><BR></font>%full_name%
|
||||||
|
</td>
|
||||||
|
<td align="right">
|
||||||
|
<table cellspacing=0 cellpadding=2>
|
||||||
|
<tr valign="top">
|
||||||
|
<td class="small-title-font">In:</td>
|
||||||
|
<td class="small-title-font">
|
||||||
|
START:infiles
|
||||||
|
HREF:full_path_url:full_path:
|
||||||
|
IF:cvsurl
|
||||||
|
(<a href="%cvsurl%">CVS</a>)
|
||||||
|
ENDIF:cvsurl
|
||||||
|
END:infiles
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
IF:parent
|
||||||
|
<tr>
|
||||||
|
<td class="small-title-font">Parent:</td>
|
||||||
|
<td class="small-title-font">
|
||||||
|
IF:par_url
|
||||||
|
<a href="%par_url%" class="cyan">
|
||||||
|
ENDIF:par_url
|
||||||
|
%parent%
|
||||||
|
IF:par_url
|
||||||
|
</a>
|
||||||
|
ENDIF:par_url
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
ENDIF:parent
|
||||||
|
</table>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
</table><br>
|
||||||
|
}
|
||||||
|
|
||||||
|
###################################################################
|
||||||
|
|
||||||
|
METHOD_LIST = %{
|
||||||
|
IF:includes
|
||||||
|
<div class="tablesubsubtitle">Uses</div><br>
|
||||||
|
<div class="name-list">
|
||||||
|
START:includes
|
||||||
|
<span class="method-name">HREF:aref:name:</span>
|
||||||
|
END:includes
|
||||||
|
</div>
|
||||||
|
ENDIF:includes
|
||||||
|
|
||||||
|
IF:method_list
|
||||||
|
START:method_list
|
||||||
|
IF:methods
|
||||||
|
<table cellpadding=5 width="100%">
|
||||||
|
<tr><td class="tablesubtitle">%type% %category% methods</td></tr>
|
||||||
|
</table>
|
||||||
|
START:methods
|
||||||
|
<table width="100%" cellspacing = 0 cellpadding=5 border=0>
|
||||||
|
<tr><td class="methodtitle">
|
||||||
|
<a name="%aref%">
|
||||||
|
<b>%name%</b>%params%
|
||||||
|
IF:codeurl
|
||||||
|
<a href="%codeurl%" target="source" class="srclink">src</a>
|
||||||
|
ENDIF:codeurl
|
||||||
|
</a></td></tr>
|
||||||
|
</table>
|
||||||
|
IF:m_desc
|
||||||
|
<div class="description">
|
||||||
|
%m_desc%
|
||||||
|
</div>
|
||||||
|
ENDIF:m_desc
|
||||||
|
END:methods
|
||||||
|
ENDIF:methods
|
||||||
|
END:method_list
|
||||||
|
ENDIF:method_list
|
||||||
|
}
|
||||||
|
|
||||||
|
=begin
|
||||||
|
=end
|
||||||
|
|
||||||
|
########################## Source code ##########################
|
||||||
|
|
||||||
|
SRC_PAGE = %{
|
||||||
|
<html>
|
||||||
|
<head><title>%title%</title>
|
||||||
|
<meta http-equiv="Content-Type" content="text/html; charset=%charset%">
|
||||||
|
<style>
|
||||||
|
.kw { color: #3333FF; font-weight: bold }
|
||||||
|
.cmt { color: green; font-style: italic }
|
||||||
|
.str { color: #662222; font-style: italic }
|
||||||
|
.re { color: #662222; }
|
||||||
|
.ruby-comment { color: green; font-style: italic }
|
||||||
|
.ruby-constant { color: #4433aa; font-weight: bold; }
|
||||||
|
.ruby-identifier { color: #222222; }
|
||||||
|
.ruby-ivar { color: #2233dd; }
|
||||||
|
.ruby-keyword { color: #3333FF; font-weight: bold }
|
||||||
|
.ruby-node { color: #777777; }
|
||||||
|
.ruby-operator { color: #111111; }
|
||||||
|
.ruby-regexp { color: #662222; }
|
||||||
|
.ruby-value { color: #662222; font-style: italic }
|
||||||
|
</style>
|
||||||
|
</head>
|
||||||
|
<body bgcolor="#BBBBBB">
|
||||||
|
<pre>%code%</pre>
|
||||||
|
</body>
|
||||||
|
</html>
|
||||||
|
}
|
||||||
|
|
||||||
|
########################## Index ################################
|
||||||
|
|
||||||
|
FR_INDEX_BODY = %{
|
||||||
|
!INCLUDE!
|
||||||
|
}
|
||||||
|
|
||||||
|
FILE_INDEX = %{
|
||||||
|
<html>
|
||||||
|
<head>
|
||||||
|
<meta http-equiv="Content-Type" content="text/html; charset=%charset%">
|
||||||
|
<style>
|
||||||
|
<!--
|
||||||
|
body {
|
||||||
|
background-color: #bbbbbb;
|
||||||
|
font-family: #{FONTS};
|
||||||
|
font-size: 11px;
|
||||||
|
font-style: normal;
|
||||||
|
line-height: 14px;
|
||||||
|
color: #000040;
|
||||||
|
}
|
||||||
|
div.banner {
|
||||||
|
background: #bbbbcc;
|
||||||
|
color: white;
|
||||||
|
padding: 1;
|
||||||
|
margin: 0;
|
||||||
|
font-size: 90%;
|
||||||
|
font-weight: bold;
|
||||||
|
line-height: 1.1;
|
||||||
|
text-align: center;
|
||||||
|
width: 100%;
|
||||||
|
}
|
||||||
|
|
||||||
|
-->
|
||||||
|
</style>
|
||||||
|
<base target="docwin">
|
||||||
|
</head>
|
||||||
|
<body>
|
||||||
|
<div class="banner">%list_title%</div>
|
||||||
|
START:entries
|
||||||
|
<a href="%href%">%name%</a><br>
|
||||||
|
END:entries
|
||||||
|
</body></html>
|
||||||
|
}
|
||||||
|
|
||||||
|
CLASS_INDEX = FILE_INDEX
|
||||||
|
METHOD_INDEX = FILE_INDEX
|
||||||
|
|
||||||
|
INDEX = %{
|
||||||
|
<html>
|
||||||
|
<head>
|
||||||
|
<title>%title%</title>
|
||||||
|
<meta http-equiv="Content-Type" content="text/html; charset=%charset%">
|
||||||
|
</head>
|
||||||
|
|
||||||
|
<frameset cols="20%,*">
|
||||||
|
<frameset rows="15%,35%,50%">
|
||||||
|
<frame src="fr_file_index.html" title="Files" name="Files">
|
||||||
|
<frame src="fr_class_index.html" name="Modules">
|
||||||
|
<frame src="fr_method_index.html" name="Subroutines and Functions">
|
||||||
|
</frameset>
|
||||||
|
<frameset rows="80%,20%">
|
||||||
|
<frame src="%initial_page%" name="docwin">
|
||||||
|
<frame src="blank.html" name="source">
|
||||||
|
</frameset>
|
||||||
|
<noframes>
|
||||||
|
<body bgcolor="#BBBBBB">
|
||||||
|
Click <a href="html/index.html">here</a> for a non-frames
|
||||||
|
version of this page.
|
||||||
|
</body>
|
||||||
|
</noframes>
|
||||||
|
</frameset>
|
||||||
|
|
||||||
|
</html>
|
||||||
|
}
|
||||||
|
|
||||||
|
# and a blank page to use as a target
|
||||||
|
BLANK = %{
|
||||||
|
<html><body bgcolor="#BBBBBB"></body></html>
|
||||||
|
}
|
||||||
|
|
||||||
|
def write_extra_pages
|
||||||
|
template = TemplatePage.new(BLANK)
|
||||||
|
File.open("blank.html", "w") { |f| template.write_html_on(f, {}) }
|
||||||
|
end
|
||||||
|
|
||||||
|
end
|
||||||
|
end
|
||||||
762
lib/rdoc/generators/template/html/html.rb
Normal file
762
lib/rdoc/generators/template/html/html.rb
Normal file
|
|
@ -0,0 +1,762 @@
|
||||||
|
module RDoc
|
||||||
|
|
||||||
|
# This is how you define the HTML that RDoc generates. Simply create
|
||||||
|
# a file in rdoc/generators/html_templates that creates the
|
||||||
|
# module RDoc::Page and populate it as described below. Then invoke
|
||||||
|
# rdoc using the --template <name of your file> option, and
|
||||||
|
# your template will be used.
|
||||||
|
#
|
||||||
|
# The constants defining pages use a simple templating system:
|
||||||
|
#
|
||||||
|
# * The templating system is passed a hash. Keys in the hash correspond
|
||||||
|
# to tags on this page. The tag %abc% is looked up in the hash,
|
||||||
|
# and is replaced by the corresponding hash value.
|
||||||
|
#
|
||||||
|
# * Some tags are optional. You can detect this using IF/ENDIF
|
||||||
|
#
|
||||||
|
# IF: title
|
||||||
|
# The value of title is %title%
|
||||||
|
# ENDIF: title
|
||||||
|
#
|
||||||
|
# * Some entries in the hash have values that are arrays, where each
|
||||||
|
# entry in the array is itself a hash. These are used to generate
|
||||||
|
# lists using the START: construct. For example, given a hash
|
||||||
|
# containing
|
||||||
|
#
|
||||||
|
# { 'people' => [ { 'name' => 'Fred', 'age' => '12' },
|
||||||
|
# { 'name' => 'Mary', 'age' => '21' } ]
|
||||||
|
#
|
||||||
|
# You could generate a simple table using
|
||||||
|
#
|
||||||
|
# <table>
|
||||||
|
# START:people
|
||||||
|
# <tr><td>%name%<td>%age%</tr>
|
||||||
|
# END:people
|
||||||
|
# </table>
|
||||||
|
#
|
||||||
|
# These lists can be nested to an arbitrary depth
|
||||||
|
#
|
||||||
|
# * the construct HREF:url:name: generates <a href="%url%">%name%</a>
|
||||||
|
# if +url+ is defined in the hash, or %name% otherwise.
|
||||||
|
#
|
||||||
|
#
|
||||||
|
# Your file must contain the following constants
|
||||||
|
#
|
||||||
|
# [*FONTS*] a list of fonts to be used
|
||||||
|
# [*STYLE*] a CSS section (without the <style> or comments). This is
|
||||||
|
# used to generate a style.css file
|
||||||
|
#
|
||||||
|
# [*BODY*]
|
||||||
|
# The main body of all non-index RDoc pages. BODY will contain
|
||||||
|
# two !INCLUDE!s. The first is used to include a document-type
|
||||||
|
# specific header (FILE_PAGE or CLASS_PAGE). The second include
|
||||||
|
# is for the method list (METHOD_LIST). THe body is passed:
|
||||||
|
#
|
||||||
|
# %title%::
|
||||||
|
# the page's title
|
||||||
|
#
|
||||||
|
# %style_url%::
|
||||||
|
# the url of a style sheet for this page
|
||||||
|
#
|
||||||
|
# %diagram%::
|
||||||
|
# the optional URL of a diagram for this page
|
||||||
|
#
|
||||||
|
# %description%::
|
||||||
|
# a (potentially multi-paragraph) string containing the
|
||||||
|
# description for th file/class/module.
|
||||||
|
#
|
||||||
|
# %requires%::
|
||||||
|
# an optional list of %aref%/%name% pairs, one for each module
|
||||||
|
# required by this file.
|
||||||
|
#
|
||||||
|
# %methods%::
|
||||||
|
# an optional list of %aref%/%name%, one for each method
|
||||||
|
# documented on this page. This is intended to be an index.
|
||||||
|
#
|
||||||
|
# %attributes%::
|
||||||
|
# An optional list. For each attribute it contains:
|
||||||
|
# %name%:: the attribute name
|
||||||
|
# %rw%:: r/o, w/o, or r/w
|
||||||
|
# %a_desc%:: description of the attribute
|
||||||
|
#
|
||||||
|
# %classlist%::
|
||||||
|
# An optional string containing an already-formatted list of
|
||||||
|
# classes and modules documented in this file
|
||||||
|
#
|
||||||
|
# For FILE_PAGE entries, the body will be passed
|
||||||
|
#
|
||||||
|
# %short_name%::
|
||||||
|
# The name of the file
|
||||||
|
#
|
||||||
|
# %full_path%::
|
||||||
|
# The full path to the file
|
||||||
|
#
|
||||||
|
# %dtm_modified%::
|
||||||
|
# The date/time the file was last changed
|
||||||
|
#
|
||||||
|
# For class and module pages, the body will be passed
|
||||||
|
#
|
||||||
|
# %classmod%::
|
||||||
|
# The name of the class or module
|
||||||
|
#
|
||||||
|
# %files%::
|
||||||
|
# A list. For each file this class is defined in, it contains:
|
||||||
|
# %full_path_url%:: an (optional) URL of the RDoc page
|
||||||
|
# for this file
|
||||||
|
# %full_path%:: the name of the file
|
||||||
|
#
|
||||||
|
# %par_url%::
|
||||||
|
# The (optional) URL of the RDoc page documenting this class's
|
||||||
|
# parent class
|
||||||
|
#
|
||||||
|
# %parent%::
|
||||||
|
# The name of this class's parent.
|
||||||
|
#
|
||||||
|
# For both files and classes, the body is passed the following information
|
||||||
|
# on includes and methods:
|
||||||
|
#
|
||||||
|
# %includes%::
|
||||||
|
# Optional list of included modules. For each, it receives
|
||||||
|
# %aref%:: optional URL to RDoc page for the module
|
||||||
|
# %name%:: the name of the module
|
||||||
|
#
|
||||||
|
# %method_list%::
|
||||||
|
# Optional list of methods of a particular class and category.
|
||||||
|
#
|
||||||
|
# Each method list entry contains:
|
||||||
|
#
|
||||||
|
# %type%:: public/private/protected
|
||||||
|
# %category%:: instance/class
|
||||||
|
# %methods%:: a list of method descriptions
|
||||||
|
#
|
||||||
|
# Each method description contains:
|
||||||
|
#
|
||||||
|
# %aref%:: a target aref, used when referencing this method
|
||||||
|
# description. You should code this as <a name="%aref%">
|
||||||
|
# %codeurl%:: the optional URL to the page containing this method's
|
||||||
|
# source code.
|
||||||
|
# %name%:: the method's name
|
||||||
|
# %params%:: the method's parameters
|
||||||
|
# %m_desc%:: the (potentially multi-paragraph) description of
|
||||||
|
# this method.
|
||||||
|
#
|
||||||
|
# [*CLASS_PAGE*]
|
||||||
|
# Header for pages documenting classes and modules. See
|
||||||
|
# BODY above for the available parameters.
|
||||||
|
#
|
||||||
|
# [*FILE_PAGE*]
|
||||||
|
# Header for pages documenting files. See
|
||||||
|
# BODY above for the available parameters.
|
||||||
|
#
|
||||||
|
# [*METHOD_LIST*]
|
||||||
|
# Controls the display of the listing of methods. See BODY for
|
||||||
|
# parameters.
|
||||||
|
#
|
||||||
|
# [*INDEX*]
|
||||||
|
# The top-level index page. For a browser-like environment
|
||||||
|
# define a frame set that includes the file, class, and
|
||||||
|
# method indices. Passed
|
||||||
|
# %title%:: title of page
|
||||||
|
# %initial_page% :: url of initial page to display
|
||||||
|
#
|
||||||
|
# [*CLASS_INDEX*]
|
||||||
|
# Individual files for the three indexes. Passed:
|
||||||
|
# %index_url%:: URL of main index page
|
||||||
|
# %entries%:: List of
|
||||||
|
# %name%:: name of an index entry
|
||||||
|
# %href%:: url of corresponding page
|
||||||
|
# [*METHOD_INDEX*]
|
||||||
|
# Same as CLASS_INDEX for methods
|
||||||
|
#
|
||||||
|
# [*FILE_INDEX*]
|
||||||
|
# Same as CLASS_INDEX for methods
|
||||||
|
#
|
||||||
|
# [*FR_INDEX_BODY*]
|
||||||
|
# A wrapper around CLASS_INDEX, METHOD_INDEX, and FILE_INDEX.
|
||||||
|
# If those index strings contain the complete HTML for the
|
||||||
|
# output, then FR_INDEX_BODY can simply be !INCLUDE!
|
||||||
|
#
|
||||||
|
# [*SRC_PAGE*]
|
||||||
|
# Page used to display source code. Passed %title% and %code%,
|
||||||
|
# the latter being a multi-line string of code.
|
||||||
|
|
||||||
|
module Page
|
||||||
|
|
||||||
|
FONTS = "Verdana, Arial, Helvetica, sans-serif"
|
||||||
|
|
||||||
|
STYLE = %{
|
||||||
|
body,td,p { font-family: %fonts%;
|
||||||
|
color: #000040;
|
||||||
|
}
|
||||||
|
|
||||||
|
.attr-rw { font-size: x-small; color: #444488 }
|
||||||
|
|
||||||
|
.title-row { background: #0000aa;
|
||||||
|
color: #eeeeff;
|
||||||
|
}
|
||||||
|
|
||||||
|
.big-title-font { color: white;
|
||||||
|
font-family: %fonts%;
|
||||||
|
font-size: large;
|
||||||
|
height: 50px}
|
||||||
|
|
||||||
|
.small-title-font { color: aqua;
|
||||||
|
font-family: %fonts%;
|
||||||
|
font-size: xx-small; }
|
||||||
|
|
||||||
|
.aqua { color: aqua }
|
||||||
|
|
||||||
|
.method-name, attr-name {
|
||||||
|
font-family: monospace; font-weight: bold;
|
||||||
|
}
|
||||||
|
|
||||||
|
.tablesubtitle, .tablesubsubtitle {
|
||||||
|
width: 100%;
|
||||||
|
margin-top: 1ex;
|
||||||
|
margin-bottom: .5ex;
|
||||||
|
padding: 5px 0px 5px 20px;
|
||||||
|
font-size: large;
|
||||||
|
color: aqua;
|
||||||
|
background: #3333cc;
|
||||||
|
}
|
||||||
|
|
||||||
|
.name-list {
|
||||||
|
font-family: monospace;
|
||||||
|
margin-left: 40px;
|
||||||
|
margin-bottom: 2ex;
|
||||||
|
line-height: 140%;
|
||||||
|
}
|
||||||
|
|
||||||
|
.description {
|
||||||
|
margin-left: 40px;
|
||||||
|
margin-top: -2ex;
|
||||||
|
margin-bottom: 2ex;
|
||||||
|
}
|
||||||
|
|
||||||
|
.description p {
|
||||||
|
line-height: 140%;
|
||||||
|
}
|
||||||
|
|
||||||
|
.aka {
|
||||||
|
margin-left: 40px;
|
||||||
|
margin-bottom: 2ex;
|
||||||
|
line-height: 100%;
|
||||||
|
font-size: small;
|
||||||
|
color: #808080;
|
||||||
|
}
|
||||||
|
|
||||||
|
.methodtitle {
|
||||||
|
font-size: medium;
|
||||||
|
text-decoration: none;
|
||||||
|
color: #0000AA;
|
||||||
|
background: white;
|
||||||
|
}
|
||||||
|
|
||||||
|
.paramsig {
|
||||||
|
font-size: small;
|
||||||
|
}
|
||||||
|
|
||||||
|
.srcbut { float: right }
|
||||||
|
|
||||||
|
pre { font-size: 1.2em; }
|
||||||
|
tt { font-size: 1.2em; }
|
||||||
|
|
||||||
|
pre.source {
|
||||||
|
border-style: groove;
|
||||||
|
background-color: #ddddff;
|
||||||
|
margin-left: 40px;
|
||||||
|
padding: 1em 0em 1em 2em;
|
||||||
|
}
|
||||||
|
|
||||||
|
.classlist {
|
||||||
|
margin-left: 40px;
|
||||||
|
margin-bottom: 2ex;
|
||||||
|
line-height: 140%;
|
||||||
|
}
|
||||||
|
|
||||||
|
li {
|
||||||
|
display: list-item;
|
||||||
|
margin-top: .6em;
|
||||||
|
}
|
||||||
|
|
||||||
|
.ruby-comment { color: green; font-style: italic }
|
||||||
|
.ruby-constant { color: #4433aa; font-weight: bold; }
|
||||||
|
.ruby-identifier { color: #222222; }
|
||||||
|
.ruby-ivar { color: #2233dd; }
|
||||||
|
.ruby-keyword { color: #3333FF; font-weight: bold }
|
||||||
|
.ruby-node { color: #777777; }
|
||||||
|
.ruby-operator { color: #111111; }
|
||||||
|
.ruby-regexp { color: #662222; }
|
||||||
|
.ruby-value { color: #662222; font-style: italic }
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
############################################################################
|
||||||
|
|
||||||
|
|
||||||
|
HEADER = %{
|
||||||
|
<?xml version="1.0" encoding="utf-8"?>
|
||||||
|
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
|
||||||
|
"DTD/xhtml1-strict.dtd">
|
||||||
|
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
|
||||||
|
<head>
|
||||||
|
<title>%title%</title>
|
||||||
|
<meta http-equiv="Content-Type" content="text/html; charset=%charset%" />
|
||||||
|
<link rel=StyleSheet href="%style_url%" type="text/css" media="screen" />
|
||||||
|
<script type="text/javascript" language="JavaScript">
|
||||||
|
<!--
|
||||||
|
function popCode(url) {
|
||||||
|
window.open(url, "Code",
|
||||||
|
"resizable=yes,scrollbars=yes,toolbar=no,status=no,height=150,width=400")
|
||||||
|
}
|
||||||
|
//-->
|
||||||
|
</script>
|
||||||
|
</head>
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
###################################################################
|
||||||
|
|
||||||
|
METHOD_LIST = %{
|
||||||
|
IF:includes
|
||||||
|
<table summary="Included modules" cellpadding="5" width="100%">
|
||||||
|
<tr><td class="tablesubtitle">Included modules</td></tr>
|
||||||
|
</table>
|
||||||
|
<div class="name-list">
|
||||||
|
START:includes
|
||||||
|
<span class="method-name">HREF:aref:name:</span>
|
||||||
|
END:includes
|
||||||
|
</div>
|
||||||
|
ENDIF:includes
|
||||||
|
|
||||||
|
IF:method_list
|
||||||
|
START:method_list
|
||||||
|
IF:methods
|
||||||
|
<table summary="Method list" cellpadding="5" width="100%">
|
||||||
|
<tr><td class="tablesubtitle">%type% %category% methods</td></tr>
|
||||||
|
</table>
|
||||||
|
START:methods
|
||||||
|
<table summary="method" width="100%" cellspacing="0" cellpadding="5" border="0">
|
||||||
|
<tr><td class="methodtitle">
|
||||||
|
<a name="%aref%"></a>
|
||||||
|
IF:codeurl
|
||||||
|
<a href="%codeurl%" target="Code" class="methodtitle"
|
||||||
|
onClick="popCode('%codeurl%');return false;">
|
||||||
|
ENDIF:codeurl
|
||||||
|
<b>%name%</b>%params%
|
||||||
|
IF:codeurl
|
||||||
|
</a>
|
||||||
|
ENDIF:codeurl
|
||||||
|
</td></tr>
|
||||||
|
</table>
|
||||||
|
IF:m_desc
|
||||||
|
<div class="description">
|
||||||
|
%m_desc%
|
||||||
|
</div>
|
||||||
|
ENDIF:m_desc
|
||||||
|
IF:aka
|
||||||
|
<div class="aka">
|
||||||
|
This method is also aliased as
|
||||||
|
START:aka
|
||||||
|
<a href="%aref%">%name%</a>
|
||||||
|
END:aka
|
||||||
|
</div>
|
||||||
|
ENDIF:aka
|
||||||
|
IF:sourcecode
|
||||||
|
<pre class="source">
|
||||||
|
%sourcecode%
|
||||||
|
</pre>
|
||||||
|
ENDIF:sourcecode
|
||||||
|
END:methods
|
||||||
|
ENDIF:methods
|
||||||
|
END:method_list
|
||||||
|
ENDIF:method_list
|
||||||
|
}
|
||||||
|
|
||||||
|
###################################################################
|
||||||
|
|
||||||
|
CONTEXT_CONTENT = %{
|
||||||
|
IF:diagram
|
||||||
|
<table summary="Diagram of classes and modules" width="100%">
|
||||||
|
<tr><td align="center">
|
||||||
|
%diagram%
|
||||||
|
</td></tr></table>
|
||||||
|
ENDIF:diagram
|
||||||
|
|
||||||
|
|
||||||
|
IF:description
|
||||||
|
<div class="description">%description%</div>
|
||||||
|
ENDIF:description
|
||||||
|
|
||||||
|
IF:requires
|
||||||
|
<table summary="Requires" cellpadding="5" width="100%">
|
||||||
|
<tr><td class="tablesubtitle">Required files</td></tr>
|
||||||
|
</table>
|
||||||
|
<div class="name-list">
|
||||||
|
START:requires
|
||||||
|
HREF:aref:name:
|
||||||
|
END:requires
|
||||||
|
</div>
|
||||||
|
ENDIF:requires
|
||||||
|
|
||||||
|
IF:methods
|
||||||
|
<table summary="Methods" cellpadding="5" width="100%">
|
||||||
|
<tr><td class="tablesubtitle">Methods</td></tr>
|
||||||
|
</table>
|
||||||
|
<div class="name-list">
|
||||||
|
START:methods
|
||||||
|
HREF:aref:name:
|
||||||
|
END:methods
|
||||||
|
</div>
|
||||||
|
ENDIF:methods
|
||||||
|
|
||||||
|
IF:constants
|
||||||
|
<table summary="Constants" cellpadding="5" width="100%">
|
||||||
|
<tr><td class="tablesubtitle">Constants</td></tr>
|
||||||
|
</table>
|
||||||
|
<table cellpadding="5">
|
||||||
|
START:constants
|
||||||
|
<tr valign="top"><td>%name%</td><td>=</td><td>%value%</td></tr>
|
||||||
|
IF:desc
|
||||||
|
<tr><td></td><td></td><td>%desc%</td></tr>
|
||||||
|
ENDIF:desc
|
||||||
|
END:constants
|
||||||
|
</table>
|
||||||
|
ENDIF:constants
|
||||||
|
|
||||||
|
IF:aliases
|
||||||
|
<table summary="Aliases" cellpadding="5" width="100%">
|
||||||
|
<tr><td class="tablesubtitle">External Aliases</td></tr>
|
||||||
|
</table>
|
||||||
|
<div class="name-list">
|
||||||
|
START:aliases
|
||||||
|
%old_name% -> %new_name%<br />
|
||||||
|
END:aliases
|
||||||
|
</div>
|
||||||
|
ENDIF:aliases
|
||||||
|
|
||||||
|
IF:attributes
|
||||||
|
<table summary="Attributes" cellpadding="5" width="100%">
|
||||||
|
<tr><td class="tablesubtitle">Attributes</td></tr>
|
||||||
|
</table>
|
||||||
|
<table summary="Attribute details" cellspacing="5">
|
||||||
|
START:attributes
|
||||||
|
<tr valign="top">
|
||||||
|
<td class="attr-name">%name%</td>
|
||||||
|
IF:rw
|
||||||
|
<td align="center" class="attr-rw"> [%rw%] </td>
|
||||||
|
ENDIF:rw
|
||||||
|
IFNOT:rw
|
||||||
|
<td></td>
|
||||||
|
ENDIF:rw
|
||||||
|
<td>%a_desc%</td>
|
||||||
|
</tr>
|
||||||
|
END:attributes
|
||||||
|
</table>
|
||||||
|
ENDIF:attributes
|
||||||
|
|
||||||
|
IF:classlist
|
||||||
|
<table summary="List of classes" cellpadding="5" width="100%">
|
||||||
|
<tr><td class="tablesubtitle">Classes and Modules</td></tr>
|
||||||
|
</table>
|
||||||
|
<div class="classlist">
|
||||||
|
%classlist%
|
||||||
|
</div>
|
||||||
|
ENDIF:classlist
|
||||||
|
}
|
||||||
|
|
||||||
|
###############################################################################
|
||||||
|
|
||||||
|
BODY = HEADER + %{
|
||||||
|
<body bgcolor="white">
|
||||||
|
!INCLUDE! <!-- banner header -->
|
||||||
|
} +
|
||||||
|
CONTEXT_CONTENT + METHOD_LIST +
|
||||||
|
%{
|
||||||
|
</body>
|
||||||
|
</html>
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
###############################################################################
|
||||||
|
|
||||||
|
FILE_PAGE = <<_FILE_PAGE_
|
||||||
|
<table summary="Information on file" width="100%">
|
||||||
|
<tr class="title-row">
|
||||||
|
<td><table summary="layout" width="100%"><tr>
|
||||||
|
<td class="big-title-font" colspan="2">%short_name%</td>
|
||||||
|
<td align="right"><table summary="layout" cellspacing="0" cellpadding="2">
|
||||||
|
<tr>
|
||||||
|
<td class="small-title-font">Path:</td>
|
||||||
|
<td class="small-title-font">%full_path%
|
||||||
|
IF:cvsurl
|
||||||
|
(<a href="%cvsurl%">CVS</a>)
|
||||||
|
ENDIF:cvsurl
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td class="small-title-font">Modified:</td>
|
||||||
|
<td class="small-title-font">%dtm_modified%</td>
|
||||||
|
</tr>
|
||||||
|
</table>
|
||||||
|
</td></tr></table></td>
|
||||||
|
</tr>
|
||||||
|
</table>
|
||||||
|
_FILE_PAGE_
|
||||||
|
|
||||||
|
###################################################################
|
||||||
|
|
||||||
|
CLASS_PAGE = %{
|
||||||
|
<table summary="Information on class" width="100%" border="0" cellspacing="0">
|
||||||
|
<tr class="title-row">
|
||||||
|
<td class="big-title-font">
|
||||||
|
<sup><font color="aqua">%classmod%</font></sup> %full_name%
|
||||||
|
</td>
|
||||||
|
<td align="right">
|
||||||
|
<table summary="layout" cellspacing="0" cellpadding="2">
|
||||||
|
<tr valign="top">
|
||||||
|
<td class="small-title-font">In:</td>
|
||||||
|
<td class="small-title-font">
|
||||||
|
START:infiles
|
||||||
|
IF:full_path_url
|
||||||
|
<a href="%full_path_url%" class="aqua">
|
||||||
|
ENDIF:full_path_url
|
||||||
|
%full_path%
|
||||||
|
IF:full_path_url
|
||||||
|
</a>
|
||||||
|
ENDIF:full_path_url
|
||||||
|
IF:cvsurl
|
||||||
|
(<a href="%cvsurl%">CVS</a>)
|
||||||
|
ENDIF:cvsurl
|
||||||
|
<br />
|
||||||
|
END:infiles
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
IF:parent
|
||||||
|
<tr>
|
||||||
|
<td class="small-title-font">Parent:</td>
|
||||||
|
<td class="small-title-font">
|
||||||
|
IF:par_url
|
||||||
|
<a href="%par_url%" class="aqua">
|
||||||
|
ENDIF:par_url
|
||||||
|
%parent%
|
||||||
|
IF:par_url
|
||||||
|
</a>
|
||||||
|
ENDIF:par_url
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
ENDIF:parent
|
||||||
|
</table>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
</table>
|
||||||
|
}
|
||||||
|
|
||||||
|
=begin
|
||||||
|
=end
|
||||||
|
|
||||||
|
########################## Source code ##########################
|
||||||
|
|
||||||
|
SRC_PAGE = %{
|
||||||
|
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
|
||||||
|
<html>
|
||||||
|
<head>
|
||||||
|
<meta http-equiv="Content-Type" content="text/html; charset=%charset%">
|
||||||
|
<title>%title%</title>
|
||||||
|
<link rel=StyleSheet href="%style_url%" type="text/css" media="screen" />
|
||||||
|
</head>
|
||||||
|
<body bgcolor="white">
|
||||||
|
<pre>%code%</pre>
|
||||||
|
</body>
|
||||||
|
</html>
|
||||||
|
}
|
||||||
|
|
||||||
|
########################## Index ################################
|
||||||
|
|
||||||
|
FR_INDEX_BODY = %{
|
||||||
|
!INCLUDE!
|
||||||
|
}
|
||||||
|
|
||||||
|
FILE_INDEX = %{
|
||||||
|
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
|
||||||
|
<html>
|
||||||
|
<head>
|
||||||
|
<meta http-equiv="Content-Type" content="text/html; charset=%charset%">
|
||||||
|
<title>%list_title%</title>
|
||||||
|
<style type="text/css">
|
||||||
|
<!--
|
||||||
|
body {
|
||||||
|
background-color: #ddddff;
|
||||||
|
font-family: #{FONTS};
|
||||||
|
font-size: 11px;
|
||||||
|
font-style: normal;
|
||||||
|
line-height: 14px;
|
||||||
|
color: #000040;
|
||||||
|
}
|
||||||
|
div.banner {
|
||||||
|
background: #0000aa;
|
||||||
|
color: white;
|
||||||
|
padding: 1;
|
||||||
|
margin: 0;
|
||||||
|
font-size: 90%;
|
||||||
|
font-weight: bold;
|
||||||
|
line-height: 1.1;
|
||||||
|
text-align: center;
|
||||||
|
width: 100%;
|
||||||
|
}
|
||||||
|
|
||||||
|
A.xx { color: white; font-weight: bold; }
|
||||||
|
-->
|
||||||
|
</style>
|
||||||
|
<base target="docwin">
|
||||||
|
</head>
|
||||||
|
<body>
|
||||||
|
<div class="banner"><a href="%index_url%" class="xx">%list_title%</a></div>
|
||||||
|
START:entries
|
||||||
|
<a href="%href%">%name%</a><br />
|
||||||
|
END:entries
|
||||||
|
</body></html>
|
||||||
|
}
|
||||||
|
|
||||||
|
CLASS_INDEX = FILE_INDEX
|
||||||
|
METHOD_INDEX = FILE_INDEX
|
||||||
|
|
||||||
|
INDEX = %{
|
||||||
|
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN">
|
||||||
|
<html>
|
||||||
|
<head>
|
||||||
|
<meta http-equiv="Content-Type" content="text/html; charset=%charset%">
|
||||||
|
<title>%title%</title></head>
|
||||||
|
|
||||||
|
<frameset rows="20%, 80%">
|
||||||
|
<frameset cols="25%,35%,45%">
|
||||||
|
<frame src="fr_file_index.html" title="Files" name="Files">
|
||||||
|
<frame src="fr_class_index.html" name="Classes">
|
||||||
|
<frame src="fr_method_index.html" name="Methods">
|
||||||
|
</frameset>
|
||||||
|
<frame src="%initial_page%" name="docwin">
|
||||||
|
<noframes>
|
||||||
|
<body bgcolor="white">
|
||||||
|
Sorry, RDoc currently only generates HTML using frames.
|
||||||
|
</body>
|
||||||
|
</noframes>
|
||||||
|
</frameset>
|
||||||
|
|
||||||
|
</html>
|
||||||
|
}
|
||||||
|
|
||||||
|
######################################################################
|
||||||
|
#
|
||||||
|
# The following is used for the -1 option
|
||||||
|
#
|
||||||
|
|
||||||
|
CONTENTS_XML = %{
|
||||||
|
IF:description
|
||||||
|
%description%
|
||||||
|
ENDIF:description
|
||||||
|
|
||||||
|
IF:requires
|
||||||
|
<h4>Requires:</h4>
|
||||||
|
<ul>
|
||||||
|
START:requires
|
||||||
|
IF:aref
|
||||||
|
<li><a href="%aref%">%name%</a></li>
|
||||||
|
ENDIF:aref
|
||||||
|
IFNOT:aref
|
||||||
|
<li>%name%</li>
|
||||||
|
ENDIF:aref
|
||||||
|
END:requires
|
||||||
|
</ul>
|
||||||
|
ENDIF:requires
|
||||||
|
|
||||||
|
IF:attributes
|
||||||
|
<h4>Attributes</h4>
|
||||||
|
<table>
|
||||||
|
START:attributes
|
||||||
|
<tr><td>%name%</td><td>%rw%</td><td>%a_desc%</td></tr>
|
||||||
|
END:attributes
|
||||||
|
</table>
|
||||||
|
ENDIF:attributes
|
||||||
|
|
||||||
|
IF:includes
|
||||||
|
<h4>Includes</h4>
|
||||||
|
<ul>
|
||||||
|
START:includes
|
||||||
|
IF:aref
|
||||||
|
<li><a href="%aref%">%name%</a></li>
|
||||||
|
ENDIF:aref
|
||||||
|
IFNOT:aref
|
||||||
|
<li>%name%</li>
|
||||||
|
ENDIF:aref
|
||||||
|
END:includes
|
||||||
|
</ul>
|
||||||
|
ENDIF:includes
|
||||||
|
|
||||||
|
IF:method_list
|
||||||
|
<h3>Methods</h3>
|
||||||
|
START:method_list
|
||||||
|
IF:methods
|
||||||
|
START:methods
|
||||||
|
<h4>%type% %category% method: <a name="%aref%">%name%%params%</a></h4>
|
||||||
|
|
||||||
|
IF:m_desc
|
||||||
|
%m_desc%
|
||||||
|
ENDIF:m_desc
|
||||||
|
|
||||||
|
IF:sourcecode
|
||||||
|
<blockquote><pre>
|
||||||
|
%sourcecode%
|
||||||
|
</pre></blockquote>
|
||||||
|
ENDIF:sourcecode
|
||||||
|
END:methods
|
||||||
|
ENDIF:methods
|
||||||
|
END:method_list
|
||||||
|
ENDIF:method_list
|
||||||
|
}
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
|
||||||
|
ONE_PAGE = %{
|
||||||
|
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
|
||||||
|
<html>
|
||||||
|
<head>
|
||||||
|
<title>%title%</title>
|
||||||
|
<meta http-equiv="Content-Type" content="text/html; charset=%charset%" />
|
||||||
|
</head>
|
||||||
|
<body>
|
||||||
|
START:files
|
||||||
|
<h2>File: %short_name%</h2>
|
||||||
|
<table>
|
||||||
|
<tr><td>Path:</td><td>%full_path%</td></tr>
|
||||||
|
<tr><td>Modified:</td><td>%dtm_modified%</td></tr>
|
||||||
|
</table>
|
||||||
|
} + CONTENTS_XML + %{
|
||||||
|
END:files
|
||||||
|
|
||||||
|
IF:classes
|
||||||
|
<h2>Classes</h2>
|
||||||
|
START:classes
|
||||||
|
IF:parent
|
||||||
|
<h3>%classmod% %full_name% < HREF:par_url:parent:</h3>
|
||||||
|
ENDIF:parent
|
||||||
|
IFNOT:parent
|
||||||
|
<h3>%classmod% %full_name%</h3>
|
||||||
|
ENDIF:parent
|
||||||
|
|
||||||
|
IF:infiles
|
||||||
|
(in files
|
||||||
|
START:infiles
|
||||||
|
HREF:full_path_url:full_path:
|
||||||
|
END:infiles
|
||||||
|
)
|
||||||
|
ENDIF:infiles
|
||||||
|
} + CONTENTS_XML + %{
|
||||||
|
END:classes
|
||||||
|
ENDIF:classes
|
||||||
|
</body>
|
||||||
|
</html>
|
||||||
|
}
|
||||||
|
|
||||||
|
end
|
||||||
|
end
|
||||||
398
lib/rdoc/generators/template/html/kilmer.rb
Normal file
398
lib/rdoc/generators/template/html/kilmer.rb
Normal file
|
|
@ -0,0 +1,398 @@
|
||||||
|
module RDoc
|
||||||
|
module Page
|
||||||
|
|
||||||
|
|
||||||
|
FONTS = "Verdana, Arial, Helvetica, sans-serif"
|
||||||
|
|
||||||
|
STYLE = %{
|
||||||
|
body,td,p { font-family: %fonts%;
|
||||||
|
color: #000040;
|
||||||
|
}
|
||||||
|
|
||||||
|
.attr-rw { font-size: xx-small; color: #444488 }
|
||||||
|
|
||||||
|
.title-row { background-color: #CCCCFF;
|
||||||
|
color: #000010;
|
||||||
|
}
|
||||||
|
|
||||||
|
.big-title-font {
|
||||||
|
color: black;
|
||||||
|
font-weight: bold;
|
||||||
|
font-family: %fonts%;
|
||||||
|
font-size: large;
|
||||||
|
height: 60px;
|
||||||
|
padding: 10px 3px 10px 3px;
|
||||||
|
}
|
||||||
|
|
||||||
|
.small-title-font { color: black;
|
||||||
|
font-family: %fonts%;
|
||||||
|
font-size:10; }
|
||||||
|
|
||||||
|
.aqua { color: black }
|
||||||
|
|
||||||
|
.method-name, .attr-name {
|
||||||
|
font-family: font-family: %fonts%;
|
||||||
|
font-weight: bold;
|
||||||
|
font-size: small;
|
||||||
|
margin-left: 20px;
|
||||||
|
color: #000033;
|
||||||
|
}
|
||||||
|
|
||||||
|
.tablesubtitle, .tablesubsubtitle {
|
||||||
|
width: 100%;
|
||||||
|
margin-top: 1ex;
|
||||||
|
margin-bottom: .5ex;
|
||||||
|
padding: 5px 0px 5px 3px;
|
||||||
|
font-size: large;
|
||||||
|
color: black;
|
||||||
|
background-color: #CCCCFF;
|
||||||
|
border: thin;
|
||||||
|
}
|
||||||
|
|
||||||
|
.name-list {
|
||||||
|
margin-left: 5px;
|
||||||
|
margin-bottom: 2ex;
|
||||||
|
line-height: 105%;
|
||||||
|
}
|
||||||
|
|
||||||
|
.description {
|
||||||
|
margin-left: 5px;
|
||||||
|
margin-bottom: 2ex;
|
||||||
|
line-height: 105%;
|
||||||
|
font-size: small;
|
||||||
|
}
|
||||||
|
|
||||||
|
.methodtitle {
|
||||||
|
font-size: small;
|
||||||
|
font-weight: bold;
|
||||||
|
text-decoration: none;
|
||||||
|
color: #000033;
|
||||||
|
background-color: white;
|
||||||
|
}
|
||||||
|
|
||||||
|
.srclink {
|
||||||
|
font-size: small;
|
||||||
|
font-weight: bold;
|
||||||
|
text-decoration: none;
|
||||||
|
color: #0000DD;
|
||||||
|
background-color: white;
|
||||||
|
}
|
||||||
|
|
||||||
|
.paramsig {
|
||||||
|
font-size: small;
|
||||||
|
}
|
||||||
|
|
||||||
|
.srcbut { float: right }
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
############################################################################
|
||||||
|
|
||||||
|
|
||||||
|
BODY = %{
|
||||||
|
<html><head>
|
||||||
|
<title>%title%</title>
|
||||||
|
<meta http-equiv="Content-Type" content="text/html; charset=%charset%">
|
||||||
|
<link rel=StyleSheet href="%style_url%" type="text/css" media=screen>
|
||||||
|
<script type="text/javascript" language="JavaScript">
|
||||||
|
<!--
|
||||||
|
function popCode(url) {
|
||||||
|
parent.frames.source.location = url
|
||||||
|
}
|
||||||
|
//-->
|
||||||
|
</script>
|
||||||
|
</head>
|
||||||
|
<body bgcolor="white">
|
||||||
|
|
||||||
|
!INCLUDE! <!-- banner header -->
|
||||||
|
|
||||||
|
IF:diagram
|
||||||
|
<table width="100%"><tr><td align="center">
|
||||||
|
%diagram%
|
||||||
|
</td></tr></table>
|
||||||
|
ENDIF:diagram
|
||||||
|
|
||||||
|
IF:description
|
||||||
|
<div class="description">%description%</div>
|
||||||
|
ENDIF:description
|
||||||
|
|
||||||
|
IF:requires
|
||||||
|
<table cellpadding=5 width="100%">
|
||||||
|
<tr><td class="tablesubtitle">Required files</td></tr>
|
||||||
|
</table><br>
|
||||||
|
<div class="name-list">
|
||||||
|
START:requires
|
||||||
|
HREF:aref:name:
|
||||||
|
END:requires
|
||||||
|
ENDIF:requires
|
||||||
|
</div>
|
||||||
|
|
||||||
|
IF:methods
|
||||||
|
<table cellpadding=5 width="100%">
|
||||||
|
<tr><td class="tablesubtitle">Methods</td></tr>
|
||||||
|
</table><br>
|
||||||
|
<div class="name-list">
|
||||||
|
START:methods
|
||||||
|
HREF:aref:name:,
|
||||||
|
END:methods
|
||||||
|
</div>
|
||||||
|
ENDIF:methods
|
||||||
|
|
||||||
|
IF:attributes
|
||||||
|
<table cellpadding=5 width="100%">
|
||||||
|
<tr><td class="tablesubtitle">Attributes</td></tr>
|
||||||
|
</table><br>
|
||||||
|
<table cellspacing=5>
|
||||||
|
START:attributes
|
||||||
|
<tr valign="top">
|
||||||
|
IF:rw
|
||||||
|
<td align="center" class="attr-rw"> [%rw%] </td>
|
||||||
|
ENDIF:rw
|
||||||
|
IFNOT:rw
|
||||||
|
<td></td>
|
||||||
|
ENDIF:rw
|
||||||
|
<td class="attr-name">%name%</td>
|
||||||
|
<td>%a_desc%</td>
|
||||||
|
</tr>
|
||||||
|
END:attributes
|
||||||
|
</table>
|
||||||
|
ENDIF:attributes
|
||||||
|
|
||||||
|
IF:classlist
|
||||||
|
<table cellpadding=5 width="100%">
|
||||||
|
<tr><td class="tablesubtitle">Classes and Modules</td></tr>
|
||||||
|
</table><br>
|
||||||
|
%classlist%<br>
|
||||||
|
ENDIF:classlist
|
||||||
|
|
||||||
|
!INCLUDE! <!-- method descriptions -->
|
||||||
|
|
||||||
|
</body>
|
||||||
|
</html>
|
||||||
|
}
|
||||||
|
|
||||||
|
###############################################################################
|
||||||
|
|
||||||
|
FILE_PAGE = <<_FILE_PAGE_
|
||||||
|
<table width="100%">
|
||||||
|
<tr class="title-row">
|
||||||
|
<td><table width="100%"><tr>
|
||||||
|
<td class="big-title-font" colspan=2><font size=-3><B>File</B><BR></font>%short_name%</td>
|
||||||
|
<td align="right"><table cellspacing=0 cellpadding=2>
|
||||||
|
<tr>
|
||||||
|
<td class="small-title-font">Path:</td>
|
||||||
|
<td class="small-title-font">%full_path%
|
||||||
|
IF:cvsurl
|
||||||
|
(<a href="%cvsurl%">CVS</a>)
|
||||||
|
ENDIF:cvsurl
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td class="small-title-font">Modified:</td>
|
||||||
|
<td class="small-title-font">%dtm_modified%</td>
|
||||||
|
</tr>
|
||||||
|
</table>
|
||||||
|
</td></tr></table></td>
|
||||||
|
</tr>
|
||||||
|
</table><br>
|
||||||
|
_FILE_PAGE_
|
||||||
|
|
||||||
|
###################################################################
|
||||||
|
|
||||||
|
CLASS_PAGE = %{
|
||||||
|
<table width="100%" border=0 cellspacing=0>
|
||||||
|
<tr class="title-row">
|
||||||
|
<td class="big-title-font">
|
||||||
|
<font size=-3><B>%classmod%</B><BR></font>%full_name%
|
||||||
|
</td>
|
||||||
|
<td align="right">
|
||||||
|
<table cellspacing=0 cellpadding=2>
|
||||||
|
<tr valign="top">
|
||||||
|
<td class="small-title-font">In:</td>
|
||||||
|
<td class="small-title-font">
|
||||||
|
START:infiles
|
||||||
|
HREF:full_path_url:full_path:
|
||||||
|
IF:cvsurl
|
||||||
|
(<a href="%cvsurl%">CVS</a>)
|
||||||
|
ENDIF:cvsurl
|
||||||
|
END:infiles
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
IF:parent
|
||||||
|
<tr>
|
||||||
|
<td class="small-title-font">Parent:</td>
|
||||||
|
<td class="small-title-font">
|
||||||
|
IF:par_url
|
||||||
|
<a href="%par_url%" class="cyan">
|
||||||
|
ENDIF:par_url
|
||||||
|
%parent%
|
||||||
|
IF:par_url
|
||||||
|
</a>
|
||||||
|
ENDIF:par_url
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
ENDIF:parent
|
||||||
|
</table>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
</table><br>
|
||||||
|
}
|
||||||
|
|
||||||
|
###################################################################
|
||||||
|
|
||||||
|
METHOD_LIST = %{
|
||||||
|
IF:includes
|
||||||
|
<div class="tablesubsubtitle">Included modules</div><br>
|
||||||
|
<div class="name-list">
|
||||||
|
START:includes
|
||||||
|
<span class="method-name">HREF:aref:name:</span>
|
||||||
|
END:includes
|
||||||
|
</div>
|
||||||
|
ENDIF:includes
|
||||||
|
|
||||||
|
IF:method_list
|
||||||
|
START:method_list
|
||||||
|
IF:methods
|
||||||
|
<table cellpadding=5 width="100%">
|
||||||
|
<tr><td class="tablesubtitle">%type% %category% methods</td></tr>
|
||||||
|
</table>
|
||||||
|
START:methods
|
||||||
|
<table width="100%" cellspacing = 0 cellpadding=5 border=0>
|
||||||
|
<tr><td class="methodtitle">
|
||||||
|
<a name="%aref%">
|
||||||
|
<b>%name%</b>%params%
|
||||||
|
IF:codeurl
|
||||||
|
<a href="%codeurl%" target="source" class="srclink">src</a>
|
||||||
|
ENDIF:codeurl
|
||||||
|
</a></td></tr>
|
||||||
|
</table>
|
||||||
|
IF:m_desc
|
||||||
|
<div class="description">
|
||||||
|
%m_desc%
|
||||||
|
</div>
|
||||||
|
ENDIF:m_desc
|
||||||
|
END:methods
|
||||||
|
ENDIF:methods
|
||||||
|
END:method_list
|
||||||
|
ENDIF:method_list
|
||||||
|
}
|
||||||
|
|
||||||
|
=begin
|
||||||
|
=end
|
||||||
|
|
||||||
|
########################## Source code ##########################
|
||||||
|
|
||||||
|
SRC_PAGE = %{
|
||||||
|
<html>
|
||||||
|
<head><title>%title%</title>
|
||||||
|
<meta http-equiv="Content-Type" content="text/html; charset=%charset%">
|
||||||
|
<style>
|
||||||
|
.ruby-comment { color: green; font-style: italic }
|
||||||
|
.ruby-constant { color: #4433aa; font-weight: bold; }
|
||||||
|
.ruby-identifier { color: #222222; }
|
||||||
|
.ruby-ivar { color: #2233dd; }
|
||||||
|
.ruby-keyword { color: #3333FF; font-weight: bold }
|
||||||
|
.ruby-node { color: #777777; }
|
||||||
|
.ruby-operator { color: #111111; }
|
||||||
|
.ruby-regexp { color: #662222; }
|
||||||
|
.ruby-value { color: #662222; font-style: italic }
|
||||||
|
.kw { color: #3333FF; font-weight: bold }
|
||||||
|
.cmt { color: green; font-style: italic }
|
||||||
|
.str { color: #662222; font-style: italic }
|
||||||
|
.re { color: #662222; }
|
||||||
|
</style>
|
||||||
|
</head>
|
||||||
|
<body bgcolor="white">
|
||||||
|
<pre>%code%</pre>
|
||||||
|
</body>
|
||||||
|
</html>
|
||||||
|
}
|
||||||
|
|
||||||
|
########################## Index ################################
|
||||||
|
|
||||||
|
FR_INDEX_BODY = %{
|
||||||
|
!INCLUDE!
|
||||||
|
}
|
||||||
|
|
||||||
|
FILE_INDEX = %{
|
||||||
|
<html>
|
||||||
|
<head>
|
||||||
|
<meta http-equiv="Content-Type" content="text/html; charset=%charset%">
|
||||||
|
<style>
|
||||||
|
<!--
|
||||||
|
body {
|
||||||
|
background-color: #ddddff;
|
||||||
|
font-family: #{FONTS};
|
||||||
|
font-size: 11px;
|
||||||
|
font-style: normal;
|
||||||
|
line-height: 14px;
|
||||||
|
color: #000040;
|
||||||
|
}
|
||||||
|
div.banner {
|
||||||
|
background: #0000aa;
|
||||||
|
color: white;
|
||||||
|
padding: 1;
|
||||||
|
margin: 0;
|
||||||
|
font-size: 90%;
|
||||||
|
font-weight: bold;
|
||||||
|
line-height: 1.1;
|
||||||
|
text-align: center;
|
||||||
|
width: 100%;
|
||||||
|
}
|
||||||
|
|
||||||
|
-->
|
||||||
|
</style>
|
||||||
|
<base target="docwin">
|
||||||
|
</head>
|
||||||
|
<body>
|
||||||
|
<div class="banner">%list_title%</div>
|
||||||
|
START:entries
|
||||||
|
<a href="%href%">%name%</a><br>
|
||||||
|
END:entries
|
||||||
|
</body></html>
|
||||||
|
}
|
||||||
|
|
||||||
|
CLASS_INDEX = FILE_INDEX
|
||||||
|
METHOD_INDEX = FILE_INDEX
|
||||||
|
|
||||||
|
INDEX = %{
|
||||||
|
<html>
|
||||||
|
<head>
|
||||||
|
<title>%title%</title>
|
||||||
|
<meta http-equiv="Content-Type" content="text/html; charset=%charset%">
|
||||||
|
</head>
|
||||||
|
|
||||||
|
<frameset cols="20%,*">
|
||||||
|
<frameset rows="15%,35%,50%">
|
||||||
|
<frame src="fr_file_index.html" title="Files" name="Files">
|
||||||
|
<frame src="fr_class_index.html" name="Classes">
|
||||||
|
<frame src="fr_method_index.html" name="Methods">
|
||||||
|
</frameset>
|
||||||
|
<frameset rows="80%,20%">
|
||||||
|
<frame src="%initial_page%" name="docwin">
|
||||||
|
<frame src="blank.html" name="source">
|
||||||
|
</frameset>
|
||||||
|
<noframes>
|
||||||
|
<body bgcolor="white">
|
||||||
|
Click <a href="html/index.html">here</a> for a non-frames
|
||||||
|
version of this page.
|
||||||
|
</body>
|
||||||
|
</noframes>
|
||||||
|
</frameset>
|
||||||
|
|
||||||
|
</html>
|
||||||
|
}
|
||||||
|
|
||||||
|
# and a blank page to use as a target
|
||||||
|
BLANK = %{
|
||||||
|
<html><body bgcolor="white"></body></html>
|
||||||
|
}
|
||||||
|
|
||||||
|
def write_extra_pages
|
||||||
|
template = TemplatePage.new(BLANK)
|
||||||
|
File.open("blank.html", "w") { |f| template.write_html_on(f, {}) }
|
||||||
|
end
|
||||||
|
|
||||||
|
end
|
||||||
|
end
|
||||||
112
lib/rdoc/generators/template/xml/rdf.rb
Normal file
112
lib/rdoc/generators/template/xml/rdf.rb
Normal file
|
|
@ -0,0 +1,112 @@
|
||||||
|
module RDoc
|
||||||
|
module Page
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
CONTENTS_RDF = %{
|
||||||
|
IF:description
|
||||||
|
<description rd:parseType="Literal">
|
||||||
|
%description%
|
||||||
|
</description>
|
||||||
|
ENDIF:description
|
||||||
|
|
||||||
|
IF:requires
|
||||||
|
START:requires
|
||||||
|
<rd:required-file rd:name="%name%" />
|
||||||
|
END:requires
|
||||||
|
ENDIF:requires
|
||||||
|
|
||||||
|
IF:attributes
|
||||||
|
START:attributes
|
||||||
|
<contents>
|
||||||
|
<Attribute rd:name="%name%">
|
||||||
|
IF:rw
|
||||||
|
<attribute-rw>%rw%</attribute-rw>
|
||||||
|
ENDIF:rw
|
||||||
|
<description rdf:parseType="Literal">%a_desc%</description>
|
||||||
|
</Attribute>
|
||||||
|
</contents>
|
||||||
|
END:attributes
|
||||||
|
ENDIF:attributes
|
||||||
|
|
||||||
|
IF:includes
|
||||||
|
<IncludedModuleList>
|
||||||
|
START:includes
|
||||||
|
<included-module rd:name="%name%" />
|
||||||
|
END:includes
|
||||||
|
</IncludedModuleList>
|
||||||
|
ENDIF:includes
|
||||||
|
|
||||||
|
IF:method_list
|
||||||
|
START:method_list
|
||||||
|
IF:methods
|
||||||
|
START:methods
|
||||||
|
<contents>
|
||||||
|
<Method rd:name="%name%" rd:visibility="%type%"
|
||||||
|
rd:category="%category%" rd:id="%aref%">
|
||||||
|
<parameters>%params%</parameters>
|
||||||
|
IF:m_desc
|
||||||
|
<description rdf:parseType="Literal">
|
||||||
|
%m_desc%
|
||||||
|
</description>
|
||||||
|
ENDIF:m_desc
|
||||||
|
IF:sourcecode
|
||||||
|
<source-code-listing rdf:parseType="Literal">
|
||||||
|
%sourcecode%
|
||||||
|
</source-code-listing>
|
||||||
|
ENDIF:sourcecode
|
||||||
|
</Method>
|
||||||
|
</contents>
|
||||||
|
END:methods
|
||||||
|
ENDIF:methods
|
||||||
|
END:method_list
|
||||||
|
ENDIF:method_list
|
||||||
|
<!-- end method list -->
|
||||||
|
}
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
|
||||||
|
ONE_PAGE = %{<?xml version="1.0" encoding="utf-8"?>
|
||||||
|
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
|
||||||
|
xmlns="http://pragprog.com/rdoc/rdoc.rdf#"
|
||||||
|
xmlns:rd="http://pragprog.com/rdoc/rdoc.rdf#">
|
||||||
|
|
||||||
|
<!-- RDoc -->
|
||||||
|
START:files
|
||||||
|
<rd:File rd:name="%short_name%" rd:id="%href%">
|
||||||
|
<path>%full_path%</path>
|
||||||
|
<dtm-modified>%dtm_modified%</dtm-modified>
|
||||||
|
} + CONTENTS_RDF + %{
|
||||||
|
</rd:File>
|
||||||
|
END:files
|
||||||
|
START:classes
|
||||||
|
<%classmod% rd:name="%full_name%" rd:id="%full_name%">
|
||||||
|
<classmod-info>
|
||||||
|
IF:infiles
|
||||||
|
<InFiles>
|
||||||
|
START:infiles
|
||||||
|
<infile>
|
||||||
|
<File rd:name="%full_path%"
|
||||||
|
IF:full_path_url
|
||||||
|
rdf:about="%full_path_url%"
|
||||||
|
ENDIF:full_path_url
|
||||||
|
/>
|
||||||
|
</infile>
|
||||||
|
END:infiles
|
||||||
|
</InFiles>
|
||||||
|
ENDIF:infiles
|
||||||
|
IF:parent
|
||||||
|
<superclass>HREF:par_url:parent:</superclass>
|
||||||
|
ENDIF:parent
|
||||||
|
</classmod-info>
|
||||||
|
} + CONTENTS_RDF + %{
|
||||||
|
</%classmod%>
|
||||||
|
END:classes
|
||||||
|
<!-- /RDoc -->
|
||||||
|
</rdf:RDF>
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
112
lib/rdoc/generators/template/xml/xml.rb
Normal file
112
lib/rdoc/generators/template/xml/xml.rb
Normal file
|
|
@ -0,0 +1,112 @@
|
||||||
|
module RDoc
|
||||||
|
module Page
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
CONTENTS_XML = %{
|
||||||
|
IF:description
|
||||||
|
<description>
|
||||||
|
%description%
|
||||||
|
</description>
|
||||||
|
ENDIF:description
|
||||||
|
<contents>
|
||||||
|
IF:requires
|
||||||
|
<required-file-list>
|
||||||
|
START:requires
|
||||||
|
<required-file name="%name%"
|
||||||
|
IF:aref
|
||||||
|
href="%aref%"
|
||||||
|
ENDIF:aref
|
||||||
|
/>
|
||||||
|
END:requires
|
||||||
|
</required-file-list>
|
||||||
|
ENDIF:requires
|
||||||
|
IF:attributes
|
||||||
|
<attribute-list>
|
||||||
|
START:attributes
|
||||||
|
<attribute name="%name%">
|
||||||
|
IF:rw
|
||||||
|
<attribute-rw>%rw%</attribute-rw>
|
||||||
|
ENDIF:rw
|
||||||
|
<description>%a_desc%</description>
|
||||||
|
</attribute>
|
||||||
|
END:attributes
|
||||||
|
</attribute-list>
|
||||||
|
ENDIF:attributes
|
||||||
|
IF:includes
|
||||||
|
<included-module-list>
|
||||||
|
START:includes
|
||||||
|
<included-module name="%name%"
|
||||||
|
IF:aref
|
||||||
|
href="%aref%"
|
||||||
|
ENDIF:aref
|
||||||
|
/>
|
||||||
|
END:includes
|
||||||
|
</included-module-list>
|
||||||
|
ENDIF:includes
|
||||||
|
IF:method_list
|
||||||
|
<method-list>
|
||||||
|
START:method_list
|
||||||
|
IF:methods
|
||||||
|
START:methods
|
||||||
|
<method name="%name%" type="%type%" category="%category%" id="%aref%">
|
||||||
|
<parameters>%params%</parameters>
|
||||||
|
IF:m_desc
|
||||||
|
<description>
|
||||||
|
%m_desc%
|
||||||
|
</description>
|
||||||
|
ENDIF:m_desc
|
||||||
|
IF:sourcecode
|
||||||
|
<source-code-listing>
|
||||||
|
%sourcecode%
|
||||||
|
</source-code-listing>
|
||||||
|
ENDIF:sourcecode
|
||||||
|
</method>
|
||||||
|
END:methods
|
||||||
|
ENDIF:methods
|
||||||
|
END:method_list
|
||||||
|
</method-list>
|
||||||
|
ENDIF:method_list
|
||||||
|
</contents>
|
||||||
|
}
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
|
||||||
|
ONE_PAGE = %{<?xml version="1.0" encoding="utf-8"?>
|
||||||
|
<rdoc>
|
||||||
|
<file-list>
|
||||||
|
START:files
|
||||||
|
<file name="%short_name%" id="%href%">
|
||||||
|
<file-info>
|
||||||
|
<path>%full_path%</path>
|
||||||
|
<dtm-modified>%dtm_modified%</dtm-modified>
|
||||||
|
</file-info>
|
||||||
|
} + CONTENTS_XML + %{
|
||||||
|
</file>
|
||||||
|
END:files
|
||||||
|
</file-list>
|
||||||
|
<class-module-list>
|
||||||
|
START:classes
|
||||||
|
<%classmod% name="%full_name%" id="%full_name%">
|
||||||
|
<classmod-info>
|
||||||
|
IF:infiles
|
||||||
|
<infiles>
|
||||||
|
START:infiles
|
||||||
|
<infile>HREF:full_path_url:full_path:</infile>
|
||||||
|
END:infiles
|
||||||
|
</infiles>
|
||||||
|
ENDIF:infiles
|
||||||
|
IF:parent
|
||||||
|
<superclass>HREF:par_url:parent:</superclass>
|
||||||
|
ENDIF:parent
|
||||||
|
</classmod-info>
|
||||||
|
} + CONTENTS_XML + %{
|
||||||
|
</%classmod%>
|
||||||
|
END:classes
|
||||||
|
</class-module-list>
|
||||||
|
</rdoc>
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
end
|
||||||
|
end
|
||||||
130
lib/rdoc/generators/xml_generator.rb
Normal file
130
lib/rdoc/generators/xml_generator.rb
Normal file
|
|
@ -0,0 +1,130 @@
|
||||||
|
|
||||||
|
require 'ftools'
|
||||||
|
|
||||||
|
require 'rdoc/options'
|
||||||
|
require 'rdoc/markup/simple_markup'
|
||||||
|
require 'rdoc/markup/simple_markup/to_html'
|
||||||
|
require 'rdoc/generators/html_generator'
|
||||||
|
|
||||||
|
module Generators
|
||||||
|
|
||||||
|
# Generate XML output as one big file
|
||||||
|
|
||||||
|
class XMLGenerator < HTMLGenerator
|
||||||
|
|
||||||
|
# Standard generator factory
|
||||||
|
def XMLGenerator.for(options)
|
||||||
|
XMLGenerator.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 << HtmlFile.new(toplevel, @options, FILE_DIR)
|
||||||
|
end
|
||||||
|
|
||||||
|
RDoc::TopLevel.all_classes_and_modules.each do |cls|
|
||||||
|
build_class_list(cls, @files[0], CLASS_DIR)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
def build_class_list(from, html_file, class_dir)
|
||||||
|
@classes << 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 = TemplatePage.new(RDoc::Page::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(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
|
||||||
|
|
||||||
|
end
|
||||||
16
lib/rdoc/markup/sample/rdoc2latex.rb
Normal file
16
lib/rdoc/markup/sample/rdoc2latex.rb
Normal file
|
|
@ -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}"
|
||||||
42
lib/rdoc/markup/sample/sample.rb
Normal file
42
lib/rdoc/markup/sample/sample.rb
Normal file
|
|
@ -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 "<html><body>"
|
||||||
|
puts markup.convert(input_string, h)
|
||||||
|
puts "</body></html>"
|
||||||
477
lib/rdoc/markup/simple_markup.rb
Normal file
477
lib/rdoc/markup/simple_markup.rb
Normal file
|
|
@ -0,0 +1,477 @@
|
||||||
|
# = Introduction
|
||||||
|
#
|
||||||
|
# SimpleMarkup parses plain text documents and attempts to decompose
|
||||||
|
# them into their constituent parts. Some of these parts are high-level:
|
||||||
|
# paragraphs, chunks of verbatim text, list entries and the like. Other
|
||||||
|
# parts happen at the character level: a piece of bold text, a word in
|
||||||
|
# code font. This markup is similar in spirit to that used on WikiWiki
|
||||||
|
# webs, where folks create web pages using a simple set of formatting
|
||||||
|
# rules.
|
||||||
|
#
|
||||||
|
# SimpleMarkup itself does no output formatting: this is left to a
|
||||||
|
# different set of classes.
|
||||||
|
#
|
||||||
|
# SimpleMarkup is extendable at runtime: you can add new markup
|
||||||
|
# elements to be recognised in the documents that SimpleMarkup parses.
|
||||||
|
#
|
||||||
|
# SimpleMarkup is intended to be the basis for a family of tools which
|
||||||
|
# share the common requirement that simple, plain-text should be
|
||||||
|
# rendered in a variety of different output formats and media. It is
|
||||||
|
# envisaged that SimpleMarkup could be the basis for formating RDoc
|
||||||
|
# style comment blocks, Wiki entries, and online FAQs.
|
||||||
|
#
|
||||||
|
# = Basic Formatting
|
||||||
|
#
|
||||||
|
# * SimpleMarkup looks for a document's natural left margin. This is
|
||||||
|
# used as the initial margin for the document.
|
||||||
|
#
|
||||||
|
# * Consecutive lines starting at this margin are considered to be a
|
||||||
|
# paragraph.
|
||||||
|
#
|
||||||
|
# * If a paragraph starts with a "*", "-", or with "<digit>.", then it is
|
||||||
|
# taken to be the start of a list. The margin in increased to be the
|
||||||
|
# first non-space following the list start flag. Subsequent lines
|
||||||
|
# should be indented to this new margin until the list ends. For
|
||||||
|
# example:
|
||||||
|
#
|
||||||
|
# * this is a list with three paragraphs in
|
||||||
|
# the first item. This is the first paragraph.
|
||||||
|
#
|
||||||
|
# And this is the second paragraph.
|
||||||
|
#
|
||||||
|
# 1. This is an indented, numbered list.
|
||||||
|
# 2. This is the second item in that list
|
||||||
|
#
|
||||||
|
# This is the third conventional paragraph in the
|
||||||
|
# first list item.
|
||||||
|
#
|
||||||
|
# * This is the second item in the original list
|
||||||
|
#
|
||||||
|
# * You can also construct labeled lists, sometimes called description
|
||||||
|
# or definition lists. Do this by putting the label in square brackets
|
||||||
|
# and indenting the list body:
|
||||||
|
#
|
||||||
|
# [cat] a small furry mammal
|
||||||
|
# that seems to sleep a lot
|
||||||
|
#
|
||||||
|
# [ant] a little insect that is known
|
||||||
|
# to enjoy picnics
|
||||||
|
#
|
||||||
|
# A minor variation on labeled lists uses two colons to separate the
|
||||||
|
# label from the list body:
|
||||||
|
#
|
||||||
|
# cat:: a small furry mammal
|
||||||
|
# that seems to sleep a lot
|
||||||
|
#
|
||||||
|
# ant:: a little insect that is known
|
||||||
|
# to enjoy picnics
|
||||||
|
#
|
||||||
|
# This latter style guarantees that the list bodies' left margins are
|
||||||
|
# aligned: think of them as a two column table.
|
||||||
|
#
|
||||||
|
# * Any line that starts to the right of the current margin is treated
|
||||||
|
# as verbatim text. This is useful for code listings. The example of a
|
||||||
|
# list above is also verbatim text.
|
||||||
|
#
|
||||||
|
# * A line starting with an equals sign (=) is treated as a
|
||||||
|
# heading. Level one headings have one equals sign, level two headings
|
||||||
|
# have two,and so on.
|
||||||
|
#
|
||||||
|
# * A line starting with three or more hyphens (at the current indent)
|
||||||
|
# generates a horizontal rule. THe more hyphens, the thicker the rule
|
||||||
|
# (within reason, and if supported by the output device)
|
||||||
|
#
|
||||||
|
# * You can use markup within text (except verbatim) to change the
|
||||||
|
# appearance of parts of that text. Out of the box, SimpleMarkup
|
||||||
|
# supports word-based and general markup.
|
||||||
|
#
|
||||||
|
# Word-based markup uses flag characters around individual words:
|
||||||
|
#
|
||||||
|
# [\*word*] displays word in a *bold* font
|
||||||
|
# [\_word_] displays word in an _emphasized_ font
|
||||||
|
# [\+word+] displays word in a +code+ font
|
||||||
|
#
|
||||||
|
# General markup affects text between a start delimiter and and end
|
||||||
|
# delimiter. Not surprisingly, these delimiters look like HTML markup.
|
||||||
|
#
|
||||||
|
# [\<b>text...</b>] displays word in a *bold* font
|
||||||
|
# [\<em>text...</em>] displays word in an _emphasized_ font
|
||||||
|
# [\<i>text...</i>] displays word in an _emphasized_ font
|
||||||
|
# [\<tt>text...</tt>] displays word in a +code+ font
|
||||||
|
#
|
||||||
|
# Unlike conventional Wiki markup, general markup can cross line
|
||||||
|
# boundaries. You can turn off the interpretation of markup by
|
||||||
|
# preceding the first character with a backslash, so \\\<b>bold
|
||||||
|
# text</b> and \\\*bold* produce \<b>bold text</b> and \*bold
|
||||||
|
# respectively.
|
||||||
|
#
|
||||||
|
# = Using SimpleMarkup
|
||||||
|
#
|
||||||
|
# For information on using SimpleMarkup programatically,
|
||||||
|
# see SM::SimpleMarkup.
|
||||||
|
#
|
||||||
|
# Author:: Dave Thomas, dave@pragmaticprogrammer.com
|
||||||
|
# Version:: 0.0
|
||||||
|
# License:: Ruby license
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
require 'rdoc/markup/simple_markup/fragments'
|
||||||
|
require 'rdoc/markup/simple_markup/lines.rb'
|
||||||
|
|
||||||
|
module SM #:nodoc:
|
||||||
|
|
||||||
|
# == Synopsis
|
||||||
|
#
|
||||||
|
# This code converts <tt>input_string</tt>, which is in the format
|
||||||
|
# described in markup/simple_markup.rb, to HTML. The conversion
|
||||||
|
# takes place in the +convert+ method, so you can use the same
|
||||||
|
# SimpleMarkup object to convert multiple input strings.
|
||||||
|
#
|
||||||
|
# require 'rdoc/markup/simple_markup'
|
||||||
|
# require 'rdoc/markup/simple_markup/to_html'
|
||||||
|
#
|
||||||
|
# p = SM::SimpleMarkup.new
|
||||||
|
# h = SM::ToHtml.new
|
||||||
|
#
|
||||||
|
# puts p.convert(input_string, h)
|
||||||
|
#
|
||||||
|
# You can extend the SimpleMarkup parser to recognise new markup
|
||||||
|
# sequences, and to add special processing for text that matches a
|
||||||
|
# regular epxression. Here we make WikiWords significant to the parser,
|
||||||
|
# and also make the sequences {word} and \<no>text...</no> signify
|
||||||
|
# strike-through text. When then subclass the HTML output class to deal
|
||||||
|
# with these:
|
||||||
|
#
|
||||||
|
# require 'rdoc/markup/simple_markup'
|
||||||
|
# require 'rdoc/markup/simple_markup/to_html'
|
||||||
|
#
|
||||||
|
# class WikiHtml < SM::ToHtml
|
||||||
|
# def handle_special_WIKIWORD(special)
|
||||||
|
# "<font color=red>" + special.text + "</font>"
|
||||||
|
# end
|
||||||
|
# end
|
||||||
|
#
|
||||||
|
# p = SM::SimpleMarkup.new
|
||||||
|
# p.add_word_pair("{", "}", :STRIKE)
|
||||||
|
# p.add_html("no", :STRIKE)
|
||||||
|
#
|
||||||
|
# p.add_special(/\b([A-Z][a-z]+[A-Z]\w+)/, :WIKIWORD)
|
||||||
|
#
|
||||||
|
# h = WikiHtml.new
|
||||||
|
# h.add_tag(:STRIKE, "<strike>", "</strike>")
|
||||||
|
#
|
||||||
|
# puts "<body>" + p.convert(ARGF.read, h) + "</body>"
|
||||||
|
#
|
||||||
|
# == Output Formatters
|
||||||
|
#
|
||||||
|
# _missing_
|
||||||
|
#
|
||||||
|
#
|
||||||
|
|
||||||
|
class SimpleMarkup
|
||||||
|
|
||||||
|
SPACE = ?\s
|
||||||
|
|
||||||
|
# List entries look like:
|
||||||
|
# * text
|
||||||
|
# 1. text
|
||||||
|
# [label] text
|
||||||
|
# label:: text
|
||||||
|
#
|
||||||
|
# Flag it as a list entry, and
|
||||||
|
# work out the indent for subsequent lines
|
||||||
|
|
||||||
|
SIMPLE_LIST_RE = /^(
|
||||||
|
( \* (?# bullet)
|
||||||
|
|- (?# bullet)
|
||||||
|
|\d+\. (?# numbered )
|
||||||
|
|[A-Za-z]\. (?# alphabetically numbered )
|
||||||
|
)
|
||||||
|
\s+
|
||||||
|
)\S/x
|
||||||
|
|
||||||
|
LABEL_LIST_RE = /^(
|
||||||
|
( \[.*?\] (?# labeled )
|
||||||
|
|\S.*:: (?# note )
|
||||||
|
)(?=\s|$)
|
||||||
|
\s*
|
||||||
|
)/x
|
||||||
|
|
||||||
|
|
||||||
|
##
|
||||||
|
# take a block of text and use various heuristics to determine
|
||||||
|
# it's structure (paragraphs, lists, and so on). Invoke an
|
||||||
|
# event handler as we identify significant chunks.
|
||||||
|
#
|
||||||
|
|
||||||
|
def initialize
|
||||||
|
@am = AttributeManager.new
|
||||||
|
@output = nil
|
||||||
|
end
|
||||||
|
|
||||||
|
##
|
||||||
|
# Add to the sequences used to add formatting to an individual word
|
||||||
|
# (such as *bold*). Matching entries will generate attibutes
|
||||||
|
# that the output formatters can recognize by their +name+
|
||||||
|
|
||||||
|
def add_word_pair(start, stop, name)
|
||||||
|
@am.add_word_pair(start, stop, name)
|
||||||
|
end
|
||||||
|
|
||||||
|
##
|
||||||
|
# Add to the sequences recognized as general markup
|
||||||
|
#
|
||||||
|
|
||||||
|
def add_html(tag, name)
|
||||||
|
@am.add_html(tag, name)
|
||||||
|
end
|
||||||
|
|
||||||
|
##
|
||||||
|
# Add to other inline sequences. For example, we could add
|
||||||
|
# WikiWords using something like:
|
||||||
|
#
|
||||||
|
# parser.add_special(/\b([A-Z][a-z]+[A-Z]\w+)/, :WIKIWORD)
|
||||||
|
#
|
||||||
|
# Each wiki word will be presented to the output formatter
|
||||||
|
# via the accept_special method
|
||||||
|
#
|
||||||
|
|
||||||
|
def add_special(pattern, name)
|
||||||
|
@am.add_special(pattern, name)
|
||||||
|
end
|
||||||
|
|
||||||
|
|
||||||
|
# We take a string, split it into lines, work out the type of
|
||||||
|
# each line, and from there deduce groups of lines (for example
|
||||||
|
# all lines in a paragraph). We then invoke the output formatter
|
||||||
|
# using a Visitor to display the result
|
||||||
|
|
||||||
|
def convert(str, op)
|
||||||
|
@lines = Lines.new(str.split(/\r?\n/).collect { |aLine|
|
||||||
|
Line.new(aLine) })
|
||||||
|
return "" if @lines.empty?
|
||||||
|
@lines.normalize
|
||||||
|
assign_types_to_lines
|
||||||
|
group = group_lines
|
||||||
|
# call the output formatter to handle the result
|
||||||
|
# group.to_a.each {|i| p i}
|
||||||
|
group.accept(@am, op)
|
||||||
|
end
|
||||||
|
|
||||||
|
|
||||||
|
#######
|
||||||
|
private
|
||||||
|
#######
|
||||||
|
|
||||||
|
|
||||||
|
##
|
||||||
|
# Look through the text at line indentation. We flag each line as being
|
||||||
|
# Blank, a paragraph, a list element, or verbatim text
|
||||||
|
#
|
||||||
|
|
||||||
|
def assign_types_to_lines(margin = 0, level = 0)
|
||||||
|
|
||||||
|
while line = @lines.next
|
||||||
|
if line.isBlank?
|
||||||
|
line.stamp(Line::BLANK, level)
|
||||||
|
next
|
||||||
|
end
|
||||||
|
|
||||||
|
# if a line contains non-blanks before the margin, then it must belong
|
||||||
|
# to an outer level
|
||||||
|
|
||||||
|
text = line.text
|
||||||
|
|
||||||
|
for i in 0...margin
|
||||||
|
if text[i] != SPACE
|
||||||
|
@lines.unget
|
||||||
|
return
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
active_line = text[margin..-1]
|
||||||
|
|
||||||
|
# Rules (horizontal lines) look like
|
||||||
|
#
|
||||||
|
# --- (three or more hyphens)
|
||||||
|
#
|
||||||
|
# The more hyphens, the thicker the rule
|
||||||
|
#
|
||||||
|
|
||||||
|
if /^(---+)\s*$/ =~ active_line
|
||||||
|
line.stamp(Line::RULE, level, $1.length-2)
|
||||||
|
next
|
||||||
|
end
|
||||||
|
|
||||||
|
# Then look for list entries. First the ones that have to have
|
||||||
|
# text following them (* xxx, - xxx, and dd. xxx)
|
||||||
|
|
||||||
|
if SIMPLE_LIST_RE =~ active_line
|
||||||
|
|
||||||
|
offset = margin + $1.length
|
||||||
|
prefix = $2
|
||||||
|
prefix_length = prefix.length
|
||||||
|
|
||||||
|
flag = case prefix
|
||||||
|
when "*","-" then ListBase::BULLET
|
||||||
|
when /^\d/ then ListBase::NUMBER
|
||||||
|
when /^[A-Z]/ then ListBase::UPPERALPHA
|
||||||
|
when /^[a-z]/ then ListBase::LOWERALPHA
|
||||||
|
else raise "Invalid List Type: #{self.inspect}"
|
||||||
|
end
|
||||||
|
|
||||||
|
line.stamp(Line::LIST, level+1, prefix, flag)
|
||||||
|
text[margin, prefix_length] = " " * prefix_length
|
||||||
|
assign_types_to_lines(offset, level + 1)
|
||||||
|
next
|
||||||
|
end
|
||||||
|
|
||||||
|
|
||||||
|
if LABEL_LIST_RE =~ active_line
|
||||||
|
offset = margin + $1.length
|
||||||
|
prefix = $2
|
||||||
|
prefix_length = prefix.length
|
||||||
|
|
||||||
|
next if handled_labeled_list(line, level, margin, offset, prefix)
|
||||||
|
end
|
||||||
|
|
||||||
|
# Headings look like
|
||||||
|
# = Main heading
|
||||||
|
# == Second level
|
||||||
|
# === Third
|
||||||
|
#
|
||||||
|
# Headings reset the level to 0
|
||||||
|
|
||||||
|
if active_line[0] == ?= and active_line =~ /^(=+)\s*(.*)/
|
||||||
|
prefix_length = $1.length
|
||||||
|
prefix_length = 6 if prefix_length > 6
|
||||||
|
line.stamp(Line::HEADING, 0, prefix_length)
|
||||||
|
line.strip_leading(margin + prefix_length)
|
||||||
|
next
|
||||||
|
end
|
||||||
|
|
||||||
|
# If the character's a space, then we have verbatim text,
|
||||||
|
# otherwise
|
||||||
|
|
||||||
|
if active_line[0] == SPACE
|
||||||
|
line.strip_leading(margin) if margin > 0
|
||||||
|
line.stamp(Line::VERBATIM, level)
|
||||||
|
else
|
||||||
|
line.stamp(Line::PARAGRAPH, level)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
# Handle labeled list entries, We have a special case
|
||||||
|
# to deal with. Because the labels can be long, they force
|
||||||
|
# the remaining block of text over the to right:
|
||||||
|
#
|
||||||
|
# this is a long label that I wrote:: and here is the
|
||||||
|
# block of text with
|
||||||
|
# a silly margin
|
||||||
|
#
|
||||||
|
# So we allow the special case. If the label is followed
|
||||||
|
# by nothing, and if the following line is indented, then
|
||||||
|
# we take the indent of that line as the new margin
|
||||||
|
#
|
||||||
|
# this is a long label that I wrote::
|
||||||
|
# here is a more reasonably indented block which
|
||||||
|
# will ab attached to the label.
|
||||||
|
#
|
||||||
|
|
||||||
|
def handled_labeled_list(line, level, margin, offset, prefix)
|
||||||
|
prefix_length = prefix.length
|
||||||
|
text = line.text
|
||||||
|
flag = nil
|
||||||
|
case prefix
|
||||||
|
when /^\[/
|
||||||
|
flag = ListBase::LABELED
|
||||||
|
prefix = prefix[1, prefix.length-2]
|
||||||
|
when /:$/
|
||||||
|
flag = ListBase::NOTE
|
||||||
|
prefix.chop!
|
||||||
|
else raise "Invalid List Type: #{self.inspect}"
|
||||||
|
end
|
||||||
|
|
||||||
|
# body is on the next line
|
||||||
|
|
||||||
|
if text.length <= offset
|
||||||
|
original_line = line
|
||||||
|
line = @lines.next
|
||||||
|
return(false) unless line
|
||||||
|
text = line.text
|
||||||
|
|
||||||
|
for i in 0..margin
|
||||||
|
if text[i] != SPACE
|
||||||
|
@lines.unget
|
||||||
|
return false
|
||||||
|
end
|
||||||
|
end
|
||||||
|
i = margin
|
||||||
|
i += 1 while text[i] == SPACE
|
||||||
|
if i >= text.length
|
||||||
|
@lines.unget
|
||||||
|
return false
|
||||||
|
else
|
||||||
|
offset = i
|
||||||
|
prefix_length = 0
|
||||||
|
@lines.delete(original_line)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
line.stamp(Line::LIST, level+1, prefix, flag)
|
||||||
|
text[margin, prefix_length] = " " * prefix_length
|
||||||
|
assign_types_to_lines(offset, level + 1)
|
||||||
|
return true
|
||||||
|
end
|
||||||
|
|
||||||
|
# Return a block consisting of fragments which are
|
||||||
|
# paragraphs, list entries or verbatim text. We merge consecutive
|
||||||
|
# lines of the same type and level together. We are also slightly
|
||||||
|
# tricky with lists: the lines following a list introduction
|
||||||
|
# look like paragraph lines at the next level, and we remap them
|
||||||
|
# into list entries instead
|
||||||
|
|
||||||
|
def group_lines
|
||||||
|
@lines.rewind
|
||||||
|
|
||||||
|
inList = false
|
||||||
|
wantedType = wantedLevel = nil
|
||||||
|
|
||||||
|
block = LineCollection.new
|
||||||
|
group = nil
|
||||||
|
|
||||||
|
while line = @lines.next
|
||||||
|
if line.level == wantedLevel and line.type == wantedType
|
||||||
|
group.add_text(line.text)
|
||||||
|
else
|
||||||
|
group = block.fragment_for(line)
|
||||||
|
block.add(group)
|
||||||
|
if line.type == Line::LIST
|
||||||
|
wantedType = Line::PARAGRAPH
|
||||||
|
else
|
||||||
|
wantedType = line.type
|
||||||
|
end
|
||||||
|
wantedLevel = line.level
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
block.normalize
|
||||||
|
block
|
||||||
|
end
|
||||||
|
|
||||||
|
## for debugging, we allow access to our line contents as text
|
||||||
|
def content
|
||||||
|
@lines.as_text
|
||||||
|
end
|
||||||
|
public :content
|
||||||
|
|
||||||
|
## for debugging, return the list of line types
|
||||||
|
def get_line_types
|
||||||
|
@lines.line_types
|
||||||
|
end
|
||||||
|
public :get_line_types
|
||||||
|
end
|
||||||
|
|
||||||
|
end
|
||||||
328
lib/rdoc/markup/simple_markup/fragments.rb
Normal file
328
lib/rdoc/markup/simple_markup/fragments.rb
Normal file
|
|
@ -0,0 +1,328 @@
|
||||||
|
require 'rdoc/markup/simple_markup/lines.rb'
|
||||||
|
require 'rdoc/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
|
||||||
|
UPPERALPHA = :UPPERALPHA
|
||||||
|
LOWERALPHA = :LOWERALPHA
|
||||||
|
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
|
||||||
|
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
|
||||||
|
# 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
|
||||||
348
lib/rdoc/markup/simple_markup/inline.rb
Normal file
348
lib/rdoc/markup/simple_markup/inline.rb
Normal file
|
|
@ -0,0 +1,348 @@
|
||||||
|
module SM
|
||||||
|
|
||||||
|
# We manage a set of attributes. Each attribute has a symbol name
|
||||||
|
# and a bit value
|
||||||
|
|
||||||
|
class Attribute
|
||||||
|
SPECIAL = 1
|
||||||
|
|
||||||
|
@@name_to_bitmap = { :_SPECIAL_ => SPECIAL }
|
||||||
|
@@next_bitmap = 2
|
||||||
|
|
||||||
|
def Attribute.bitmap_for(name)
|
||||||
|
bitmap = @@name_to_bitmap[name]
|
||||||
|
if !bitmap
|
||||||
|
bitmap = @@next_bitmap
|
||||||
|
@@next_bitmap <<= 1
|
||||||
|
@@name_to_bitmap[name] = bitmap
|
||||||
|
end
|
||||||
|
bitmap
|
||||||
|
end
|
||||||
|
|
||||||
|
def Attribute.as_string(bitmap)
|
||||||
|
return "none" if bitmap.zero?
|
||||||
|
res = []
|
||||||
|
@@name_to_bitmap.each do |name, bit|
|
||||||
|
res << name if (bitmap & bit) != 0
|
||||||
|
end
|
||||||
|
res.join(",")
|
||||||
|
end
|
||||||
|
|
||||||
|
def Attribute.each_name_of(bitmap)
|
||||||
|
@@name_to_bitmap.each do |name, bit|
|
||||||
|
next if bit == SPECIAL
|
||||||
|
yield name.to_s if (bitmap & bit) != 0
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
|
||||||
|
# An AttrChanger records a change in attributes. It contains
|
||||||
|
# a bitmap of the attributes to turn on, and a bitmap of those to
|
||||||
|
# turn off
|
||||||
|
|
||||||
|
AttrChanger = Struct.new(:turn_on, :turn_off)
|
||||||
|
class AttrChanger
|
||||||
|
def to_s
|
||||||
|
"Attr: +#{Attribute.as_string(@turn_on)}/-#{Attribute.as_string(@turn_on)}"
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
# An array of attributes which parallels the characters in a string
|
||||||
|
class AttrSpan
|
||||||
|
def initialize(length)
|
||||||
|
@attrs = Array.new(length, 0)
|
||||||
|
end
|
||||||
|
|
||||||
|
def set_attrs(start, length, bits)
|
||||||
|
for i in start ... (start+length)
|
||||||
|
@attrs[i] |= bits
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
def [](n)
|
||||||
|
@attrs[n]
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
##
|
||||||
|
# Hold details of a special sequence
|
||||||
|
|
||||||
|
class Special
|
||||||
|
attr_reader :type
|
||||||
|
attr_accessor :text
|
||||||
|
|
||||||
|
def initialize(type, text)
|
||||||
|
@type, @text = type, text
|
||||||
|
end
|
||||||
|
|
||||||
|
def ==(o)
|
||||||
|
self.text == o.text && self.type == o.type
|
||||||
|
end
|
||||||
|
|
||||||
|
def to_s
|
||||||
|
"Special: type=#{type}, text=#{text.dump}"
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
class AttributeManager
|
||||||
|
|
||||||
|
NULL = "\000".freeze
|
||||||
|
|
||||||
|
##
|
||||||
|
# We work by substituting non-printing characters in to the
|
||||||
|
# text. For now I'm assuming that I can substitute
|
||||||
|
# a character in the range 0..8 for a 7 bit character
|
||||||
|
# without damaging the encoded string, but this might
|
||||||
|
# be optimistic
|
||||||
|
#
|
||||||
|
|
||||||
|
=begin
|
||||||
|
ATTR_FLAG = 001
|
||||||
|
A_START = 002
|
||||||
|
A_END = 003
|
||||||
|
A_SPECIAL_START = 005
|
||||||
|
A_SPECIAL_END = 006
|
||||||
|
|
||||||
|
START_ATTR = ATTR_FLAG.chr + A_START.chr
|
||||||
|
END_ATTR = ATTR_FLAG.chr + A_END.chr
|
||||||
|
|
||||||
|
START_SPECIAL = ATTR_FLAG.chr + A_SPECIAL_START.chr
|
||||||
|
END_SPECIAL = ATTR_FLAG.chr + A_SPECIAL_END.chr
|
||||||
|
|
||||||
|
=end
|
||||||
|
A_PROTECT = 004
|
||||||
|
PROTECT_ATTR = A_PROTECT.chr
|
||||||
|
|
||||||
|
# This maps delimiters that occur around words (such as
|
||||||
|
# *bold* or +tt+) where the start and end delimiters
|
||||||
|
# and the same. This lets us optimize the regexp
|
||||||
|
MATCHING_WORD_PAIRS = {}
|
||||||
|
|
||||||
|
# And this is used when the delimiters aren't the same. In this
|
||||||
|
# case the hash maps a pattern to the attribute character
|
||||||
|
WORD_PAIR_MAP = {}
|
||||||
|
|
||||||
|
# This maps HTML tags to the corresponding attribute char
|
||||||
|
HTML_TAGS = {}
|
||||||
|
|
||||||
|
# And this maps _special_ sequences to a name. A special sequence
|
||||||
|
# is something like a WikiWord
|
||||||
|
SPECIAL = {}
|
||||||
|
|
||||||
|
# Return an attribute object with the given turn_on
|
||||||
|
# and turn_off bits set
|
||||||
|
|
||||||
|
def attribute(turn_on, turn_off)
|
||||||
|
AttrChanger.new(turn_on, turn_off)
|
||||||
|
end
|
||||||
|
|
||||||
|
|
||||||
|
def change_attribute(current, new)
|
||||||
|
diff = current ^ new
|
||||||
|
attribute(new & diff, current & diff)
|
||||||
|
end
|
||||||
|
|
||||||
|
def changed_attribute_by_name(current_set, new_set)
|
||||||
|
current = new = 0
|
||||||
|
current_set.each {|name| current |= Attribute.bitmap_for(name) }
|
||||||
|
new_set.each {|name| new |= Attribute.bitmap_for(name) }
|
||||||
|
change_attribute(current, new)
|
||||||
|
end
|
||||||
|
|
||||||
|
def copy_string(start_pos, end_pos)
|
||||||
|
res = @str[start_pos...end_pos]
|
||||||
|
res.gsub!(/\000/, '')
|
||||||
|
res
|
||||||
|
end
|
||||||
|
|
||||||
|
# Map attributes like <b>text</b>to the sequence \001\002<char>\001\003<char>,
|
||||||
|
# where <char> is a per-attribute specific character
|
||||||
|
|
||||||
|
def convert_attrs(str, attrs)
|
||||||
|
# first do matching ones
|
||||||
|
tags = MATCHING_WORD_PAIRS.keys.join("")
|
||||||
|
re = "(^|\\W)([#{tags}])([A-Za-z_]+?)\\2(\\W|\$)"
|
||||||
|
# re = "(^|\\W)([#{tags}])(\\S+?)\\2(\\W|\$)"
|
||||||
|
1 while str.gsub!(Regexp.new(re)) {
|
||||||
|
attr = MATCHING_WORD_PAIRS[$2];
|
||||||
|
attrs.set_attrs($`.length + $1.length + $2.length, $3.length, attr)
|
||||||
|
$1 + NULL*$2.length + $3 + NULL*$2.length + $4
|
||||||
|
}
|
||||||
|
|
||||||
|
# then non-matching
|
||||||
|
unless WORD_PAIR_MAP.empty?
|
||||||
|
WORD_PAIR_MAP.each do |regexp, attr|
|
||||||
|
str.gsub!(regexp) {
|
||||||
|
attrs.set_attrs($`.length + $1.length, $2.length, attr)
|
||||||
|
NULL*$1.length + $2 + NULL*$3.length
|
||||||
|
}
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
def convert_html(str, attrs)
|
||||||
|
tags = HTML_TAGS.keys.join("|")
|
||||||
|
re = "<(#{tags})>(.*?)</\\1>"
|
||||||
|
1 while str.gsub!(Regexp.new(re, Regexp::IGNORECASE)) {
|
||||||
|
attr = HTML_TAGS[$1.downcase]
|
||||||
|
html_length = $1.length + 2
|
||||||
|
seq = NULL * html_length
|
||||||
|
attrs.set_attrs($`.length + html_length, $2.length, attr)
|
||||||
|
seq + $2 + seq + NULL
|
||||||
|
}
|
||||||
|
end
|
||||||
|
|
||||||
|
def convert_specials(str, attrs)
|
||||||
|
unless SPECIAL.empty?
|
||||||
|
SPECIAL.each do |regexp, attr|
|
||||||
|
str.scan(regexp) do
|
||||||
|
attrs.set_attrs($`.length, $1.length, attr | Attribute::SPECIAL)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
# A \ in front of a character that would normally be
|
||||||
|
# processed turns off processing. We do this by turning
|
||||||
|
# \< into <#{PROTECT}
|
||||||
|
|
||||||
|
PROTECTABLE = [ "<" << "\\" ] #"
|
||||||
|
|
||||||
|
|
||||||
|
def mask_protected_sequences
|
||||||
|
protect_pattern = Regexp.new("\\\\([#{Regexp.escape(PROTECTABLE.join(''))}])")
|
||||||
|
@str.gsub!(protect_pattern, "\\1#{PROTECT_ATTR}")
|
||||||
|
end
|
||||||
|
|
||||||
|
def unmask_protected_sequences
|
||||||
|
@str.gsub!(/(.)#{PROTECT_ATTR}/, '\1')
|
||||||
|
end
|
||||||
|
|
||||||
|
def initialize
|
||||||
|
add_word_pair("*", "*", :BOLD)
|
||||||
|
add_word_pair("_", "_", :EM)
|
||||||
|
add_word_pair("+", "+", :TT)
|
||||||
|
|
||||||
|
add_html("em", :EM)
|
||||||
|
add_html("i", :EM)
|
||||||
|
add_html("b", :BOLD)
|
||||||
|
add_html("tt", :TT)
|
||||||
|
end
|
||||||
|
|
||||||
|
def add_word_pair(start, stop, name)
|
||||||
|
raise "Word flags may not start '<'" if start[0] == ?<
|
||||||
|
bitmap = Attribute.bitmap_for(name)
|
||||||
|
if start == stop
|
||||||
|
MATCHING_WORD_PAIRS[start] = bitmap
|
||||||
|
else
|
||||||
|
pattern = Regexp.new("(" + Regexp.escape(start) + ")" +
|
||||||
|
# "([A-Za-z]+)" +
|
||||||
|
"(\\S+)" +
|
||||||
|
"(" + Regexp.escape(stop) +")")
|
||||||
|
WORD_PAIR_MAP[pattern] = bitmap
|
||||||
|
end
|
||||||
|
PROTECTABLE << start[0,1]
|
||||||
|
PROTECTABLE.uniq!
|
||||||
|
end
|
||||||
|
|
||||||
|
def add_html(tag, name)
|
||||||
|
HTML_TAGS[tag.downcase] = Attribute.bitmap_for(name)
|
||||||
|
end
|
||||||
|
|
||||||
|
def add_special(pattern, name)
|
||||||
|
SPECIAL[pattern] = Attribute.bitmap_for(name)
|
||||||
|
end
|
||||||
|
|
||||||
|
def flow(str)
|
||||||
|
@str = str
|
||||||
|
@attrs = AttrSpan.new(str.length)
|
||||||
|
|
||||||
|
puts("Before flow, str='#{@str.dump}'") if $DEBUG
|
||||||
|
mask_protected_sequences
|
||||||
|
convert_attrs(@str, @attrs)
|
||||||
|
convert_html(@str, @attrs)
|
||||||
|
convert_specials(str, @attrs)
|
||||||
|
unmask_protected_sequences
|
||||||
|
puts("After flow, str='#{@str.dump}'") if $DEBUG
|
||||||
|
return split_into_flow
|
||||||
|
end
|
||||||
|
|
||||||
|
def display_attributes
|
||||||
|
puts
|
||||||
|
puts @str.tr(NULL, "!")
|
||||||
|
bit = 1
|
||||||
|
16.times do |bno|
|
||||||
|
line = ""
|
||||||
|
@str.length.times do |i|
|
||||||
|
if (@attrs[i] & bit) == 0
|
||||||
|
line << " "
|
||||||
|
else
|
||||||
|
if bno.zero?
|
||||||
|
line << "S"
|
||||||
|
else
|
||||||
|
line << ("%d" % (bno+1))
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
puts(line) unless line =~ /^ *$/
|
||||||
|
bit <<= 1
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
def split_into_flow
|
||||||
|
|
||||||
|
display_attributes if $DEBUG
|
||||||
|
|
||||||
|
res = []
|
||||||
|
current_attr = 0
|
||||||
|
str = ""
|
||||||
|
|
||||||
|
|
||||||
|
str_len = @str.length
|
||||||
|
|
||||||
|
# skip leading invisible text
|
||||||
|
i = 0
|
||||||
|
i += 1 while i < str_len and @str[i].zero?
|
||||||
|
start_pos = i
|
||||||
|
|
||||||
|
# then scan the string, chunking it on attribute changes
|
||||||
|
while i < str_len
|
||||||
|
new_attr = @attrs[i]
|
||||||
|
if new_attr != current_attr
|
||||||
|
if i > start_pos
|
||||||
|
res << copy_string(start_pos, i)
|
||||||
|
start_pos = i
|
||||||
|
end
|
||||||
|
|
||||||
|
res << change_attribute(current_attr, new_attr)
|
||||||
|
current_attr = new_attr
|
||||||
|
|
||||||
|
if (current_attr & Attribute::SPECIAL) != 0
|
||||||
|
i += 1 while i < str_len and (@attrs[i] & Attribute::SPECIAL) != 0
|
||||||
|
res << Special.new(current_attr, copy_string(start_pos, i))
|
||||||
|
start_pos = i
|
||||||
|
next
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
# move on, skipping any invisible characters
|
||||||
|
begin
|
||||||
|
i += 1
|
||||||
|
end while i < str_len and @str[i].zero?
|
||||||
|
end
|
||||||
|
|
||||||
|
# tidy up trailing text
|
||||||
|
if start_pos < str_len
|
||||||
|
res << copy_string(start_pos, str_len)
|
||||||
|
end
|
||||||
|
|
||||||
|
# and reset to all attributes off
|
||||||
|
res << change_attribute(current_attr, 0) if current_attr != 0
|
||||||
|
|
||||||
|
return res
|
||||||
|
end
|
||||||
|
|
||||||
|
end
|
||||||
|
|
||||||
|
end
|
||||||
151
lib/rdoc/markup/simple_markup/lines.rb
Normal file
151
lib/rdoc/markup/simple_markup/lines.rb
Normal file
|
|
@ -0,0 +1,151 @@
|
||||||
|
##########################################################################
|
||||||
|
#
|
||||||
|
# We store the lines we're working on as objects of class Line.
|
||||||
|
# These contain the text of the line, along with a flag indicating the
|
||||||
|
# line type, and an indentation level
|
||||||
|
|
||||||
|
module SM
|
||||||
|
|
||||||
|
class Line
|
||||||
|
INFINITY = 9999
|
||||||
|
|
||||||
|
BLANK = :BLANK
|
||||||
|
HEADING = :HEADING
|
||||||
|
LIST = :LIST
|
||||||
|
RULE = :RULE
|
||||||
|
PARAGRAPH = :PARAGRAPH
|
||||||
|
VERBATIM = :VERBATIM
|
||||||
|
|
||||||
|
# line type
|
||||||
|
attr_accessor :type
|
||||||
|
|
||||||
|
# The indentation nesting level
|
||||||
|
attr_accessor :level
|
||||||
|
|
||||||
|
# The contents
|
||||||
|
attr_accessor :text
|
||||||
|
|
||||||
|
# A prefix or parameter. For LIST lines, this is
|
||||||
|
# the text that introduced the list item (the label)
|
||||||
|
attr_accessor :param
|
||||||
|
|
||||||
|
# A flag. For list lines, this is the type of the list
|
||||||
|
attr_accessor :flag
|
||||||
|
|
||||||
|
# the number of leading spaces
|
||||||
|
attr_accessor :leading_spaces
|
||||||
|
|
||||||
|
# true if this line has been deleted from the list of lines
|
||||||
|
attr_accessor :deleted
|
||||||
|
|
||||||
|
|
||||||
|
def initialize(text)
|
||||||
|
@text = text.dup
|
||||||
|
@deleted = false
|
||||||
|
|
||||||
|
# expand tabs
|
||||||
|
1 while @text.gsub!(/\t+/) { ' ' * (8*$&.length - $`.length % 8)} && $~ #`
|
||||||
|
|
||||||
|
# Strip trailing whitespace
|
||||||
|
@text.sub!(/\s+$/, '')
|
||||||
|
|
||||||
|
# and look for leading whitespace
|
||||||
|
if @text.length > 0
|
||||||
|
@text =~ /^(\s*)/
|
||||||
|
@leading_spaces = $1.length
|
||||||
|
else
|
||||||
|
@leading_spaces = INFINITY
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
# Return true if this line is blank
|
||||||
|
def isBlank?
|
||||||
|
@text.length.zero?
|
||||||
|
end
|
||||||
|
|
||||||
|
# stamp a line with a type, a level, a prefix, and a flag
|
||||||
|
def stamp(type, level, param="", flag=nil)
|
||||||
|
@type, @level, @param, @flag = type, level, param, flag
|
||||||
|
end
|
||||||
|
|
||||||
|
##
|
||||||
|
# Strip off the leading margin
|
||||||
|
#
|
||||||
|
|
||||||
|
def strip_leading(size)
|
||||||
|
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 # for debugging
|
||||||
|
|
||||||
|
def initialize(lines)
|
||||||
|
@lines = lines
|
||||||
|
rewind
|
||||||
|
end
|
||||||
|
|
||||||
|
def empty?
|
||||||
|
@lines.size.zero?
|
||||||
|
end
|
||||||
|
|
||||||
|
def each
|
||||||
|
@lines.each do |line|
|
||||||
|
yield line unless line.deleted
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
# def [](index)
|
||||||
|
# @lines[index]
|
||||||
|
# end
|
||||||
|
|
||||||
|
def rewind
|
||||||
|
@nextline = 0
|
||||||
|
end
|
||||||
|
|
||||||
|
def next
|
||||||
|
begin
|
||||||
|
res = @lines[@nextline]
|
||||||
|
@nextline += 1 if @nextline < @lines.size
|
||||||
|
end while res and res.deleted and @nextline < @lines.size
|
||||||
|
res
|
||||||
|
end
|
||||||
|
|
||||||
|
def unget
|
||||||
|
@nextline -= 1
|
||||||
|
end
|
||||||
|
|
||||||
|
def delete(a_line)
|
||||||
|
a_line.deleted = true
|
||||||
|
end
|
||||||
|
|
||||||
|
def normalize
|
||||||
|
margin = @lines.collect{|l| l.leading_spaces}.min
|
||||||
|
margin = 0 if margin == Line::INFINITY
|
||||||
|
@lines.each {|line| line.strip_leading(margin) } if margin > 0
|
||||||
|
end
|
||||||
|
|
||||||
|
def as_text
|
||||||
|
@lines.map {|l| l.text}.join("\n")
|
||||||
|
end
|
||||||
|
|
||||||
|
def line_types
|
||||||
|
@lines.map {|l| l.type }
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
68
lib/rdoc/markup/simple_markup/preprocess.rb
Normal file
68
lib/rdoc/markup/simple_markup/preprocess.rb
Normal file
|
|
@ -0,0 +1,68 @@
|
||||||
|
module SM
|
||||||
|
|
||||||
|
##
|
||||||
|
# Handle common directives that can occur in a block of text:
|
||||||
|
#
|
||||||
|
# : include : filename
|
||||||
|
#
|
||||||
|
|
||||||
|
class PreProcess
|
||||||
|
|
||||||
|
def initialize(input_file_name, include_path)
|
||||||
|
@input_file_name = input_file_name
|
||||||
|
@include_path = include_path
|
||||||
|
end
|
||||||
|
|
||||||
|
# Look for common options in a chunk of text. Options that
|
||||||
|
# we don't handle are passed back to our caller
|
||||||
|
# as |directive, param|
|
||||||
|
|
||||||
|
def handle(text)
|
||||||
|
text.gsub!(/^([ \t#]*):(\w+):\s*(.+)?\n/) do
|
||||||
|
|
||||||
|
directive = $2.downcase
|
||||||
|
param = $3
|
||||||
|
|
||||||
|
case directive
|
||||||
|
|
||||||
|
when "include"
|
||||||
|
include_file($3, $1)
|
||||||
|
|
||||||
|
else
|
||||||
|
yield(directive, param)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
#######
|
||||||
|
private
|
||||||
|
#######
|
||||||
|
|
||||||
|
# Include a file, indenting it correctly
|
||||||
|
|
||||||
|
def include_file(name, indent)
|
||||||
|
if (full_name = find_include_file(name))
|
||||||
|
content = File.open(full_name) {|f| f.read}
|
||||||
|
res = content.gsub(/^#?/, indent)
|
||||||
|
else
|
||||||
|
$stderr.puts "Couldn't find file to include: '#{name}'"
|
||||||
|
''
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
# Look for the given file in the directory containing the current
|
||||||
|
# file, and then in each of the directories specified in the
|
||||||
|
# RDOC_INCLUDE path
|
||||||
|
|
||||||
|
def find_include_file(name)
|
||||||
|
to_search = [ File.dirname(@input_file_name) ].concat @include_path
|
||||||
|
to_search.each do |dir|
|
||||||
|
full_name = File.join(dir, name)
|
||||||
|
stat = File.stat(full_name) rescue next
|
||||||
|
return full_name if stat.readable?
|
||||||
|
end
|
||||||
|
nil
|
||||||
|
end
|
||||||
|
|
||||||
|
end
|
||||||
|
end
|
||||||
289
lib/rdoc/markup/simple_markup/to_html.rb
Normal file
289
lib/rdoc/markup/simple_markup/to_html.rb
Normal file
|
|
@ -0,0 +1,289 @@
|
||||||
|
require 'rdoc/markup/simple_markup/fragments'
|
||||||
|
require 'rdoc/markup/simple_markup/inline'
|
||||||
|
|
||||||
|
require 'cgi'
|
||||||
|
|
||||||
|
module SM
|
||||||
|
|
||||||
|
class ToHtml
|
||||||
|
|
||||||
|
LIST_TYPE_TO_HTML = {
|
||||||
|
ListBase::BULLET => [ "<ul>", "</ul>" ],
|
||||||
|
ListBase::NUMBER => [ "<ol>", "</ol>" ],
|
||||||
|
ListBase::UPPERALPHA => [ "<ol>", "</ol>" ],
|
||||||
|
ListBase::LOWERALPHA => [ "<ol>", "</ol>" ],
|
||||||
|
ListBase::LABELED => [ "<dl>", "</dl>" ],
|
||||||
|
ListBase::NOTE => [ "<table>", "</table>" ],
|
||||||
|
}
|
||||||
|
|
||||||
|
InlineTag = Struct.new(:bit, :on, :off)
|
||||||
|
|
||||||
|
def initialize
|
||||||
|
init_tags
|
||||||
|
end
|
||||||
|
|
||||||
|
##
|
||||||
|
# Set up the standard mapping of attributes to HTML tags
|
||||||
|
#
|
||||||
|
def init_tags
|
||||||
|
@attr_tags = [
|
||||||
|
InlineTag.new(SM::Attribute.bitmap_for(:BOLD), "<b>", "</b>"),
|
||||||
|
InlineTag.new(SM::Attribute.bitmap_for(:TT), "<tt>", "</tt>"),
|
||||||
|
InlineTag.new(SM::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(SM::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 = ""
|
||||||
|
@in_list_entry = []
|
||||||
|
end
|
||||||
|
|
||||||
|
def end_accepting
|
||||||
|
@res
|
||||||
|
end
|
||||||
|
|
||||||
|
def accept_paragraph(am, fragment)
|
||||||
|
@res << annotate("<p>") + "\n"
|
||||||
|
@res << wrap(convert_flow(am.flow(fragment.txt)))
|
||||||
|
@res << annotate("</p>") + "\n"
|
||||||
|
end
|
||||||
|
|
||||||
|
def accept_verbatim(am, fragment)
|
||||||
|
@res << annotate("<pre>") + "\n"
|
||||||
|
@res << CGI.escapeHTML(fragment.txt)
|
||||||
|
@res << annotate("</pre>") << "\n"
|
||||||
|
end
|
||||||
|
|
||||||
|
def accept_rule(am, fragment)
|
||||||
|
size = fragment.param
|
||||||
|
size = 10 if size > 10
|
||||||
|
@res << "<hr size=\"#{size}\"></hr>"
|
||||||
|
end
|
||||||
|
|
||||||
|
def accept_list_start(am, fragment)
|
||||||
|
@res << html_list_name(fragment.type, true) <<"\n"
|
||||||
|
@in_list_entry.push false
|
||||||
|
end
|
||||||
|
|
||||||
|
def accept_list_end(am, fragment)
|
||||||
|
if tag = @in_list_entry.pop
|
||||||
|
@res << annotate(tag) << "\n"
|
||||||
|
end
|
||||||
|
@res << html_list_name(fragment.type, false) <<"\n"
|
||||||
|
end
|
||||||
|
|
||||||
|
def accept_list_item(am, fragment)
|
||||||
|
if tag = @in_list_entry.last
|
||||||
|
@res << annotate(tag) << "\n"
|
||||||
|
end
|
||||||
|
@res << list_item_start(am, fragment)
|
||||||
|
@res << wrap(convert_flow(am.flow(fragment.txt))) << "\n"
|
||||||
|
@in_list_entry[-1] = list_end_for(fragment.type)
|
||||||
|
end
|
||||||
|
|
||||||
|
def accept_blank_line(am, fragment)
|
||||||
|
# @res << annotate("<p />") << "\n"
|
||||||
|
end
|
||||||
|
|
||||||
|
def accept_heading(am, fragment)
|
||||||
|
@res << convert_heading(fragment.head_level, am.flow(fragment.txt))
|
||||||
|
end
|
||||||
|
|
||||||
|
# This is a higher speed (if messier) version of wrap
|
||||||
|
|
||||||
|
def wrap(txt, line_len = 76)
|
||||||
|
res = ""
|
||||||
|
sp = 0
|
||||||
|
ep = txt.length
|
||||||
|
while sp < ep
|
||||||
|
# scan back for a space
|
||||||
|
p = sp + line_len - 1
|
||||||
|
if p >= ep
|
||||||
|
p = ep
|
||||||
|
else
|
||||||
|
while p > sp and txt[p] != ?\s
|
||||||
|
p -= 1
|
||||||
|
end
|
||||||
|
if p <= sp
|
||||||
|
p = sp + line_len
|
||||||
|
while p < ep and txt[p] != ?\s
|
||||||
|
p += 1
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
res << txt[sp...p] << "\n"
|
||||||
|
sp = p
|
||||||
|
sp += 1 while sp < ep and txt[sp] == ?\s
|
||||||
|
end
|
||||||
|
res
|
||||||
|
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
|
||||||
|
|
||||||
|
# some of these patterns are taken from SmartyPants...
|
||||||
|
|
||||||
|
def convert_string(item)
|
||||||
|
CGI.escapeHTML(item).
|
||||||
|
|
||||||
|
|
||||||
|
# convert -- to em-dash, (-- to en-dash)
|
||||||
|
gsub(/---?/, '—'). #gsub(/--/, '–').
|
||||||
|
|
||||||
|
# convert ... to elipsis (and make sure .... becomes .<elipsis>)
|
||||||
|
gsub(/\.\.\.\./, '.…').gsub(/\.\.\./, '…').
|
||||||
|
|
||||||
|
# convert single closing quote
|
||||||
|
gsub(%r{([^ \t\r\n\[\{\(])\'}) { "#$1’" }.
|
||||||
|
gsub(%r{\'(?=\W|s\b)}) { "’" }.
|
||||||
|
|
||||||
|
# convert single opening quote
|
||||||
|
gsub(/'/, '‘').
|
||||||
|
|
||||||
|
# convert double closing quote
|
||||||
|
gsub(%r{([^ \t\r\n\[\{\(])\'(?=\W)}) { "#$1”" }.
|
||||||
|
|
||||||
|
# convert double opening quote
|
||||||
|
gsub(/'/, '“').
|
||||||
|
|
||||||
|
# convert copyright
|
||||||
|
gsub(/\(c\)/, '©').
|
||||||
|
|
||||||
|
# convert and registered trademark
|
||||||
|
gsub(/\(r\)/, '®')
|
||||||
|
|
||||||
|
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
|
||||||
|
|
||||||
|
def convert_heading(level, flow)
|
||||||
|
res =
|
||||||
|
annotate("<h#{level}>") +
|
||||||
|
convert_flow(flow) +
|
||||||
|
annotate("</h#{level}>\n")
|
||||||
|
end
|
||||||
|
|
||||||
|
def html_list_name(list_type, is_open_tag)
|
||||||
|
tags = LIST_TYPE_TO_HTML[list_type] || raise("Invalid list type: #{list_type.inspect}")
|
||||||
|
annotate(tags[ is_open_tag ? 0 : 1])
|
||||||
|
end
|
||||||
|
|
||||||
|
def list_item_start(am, fragment)
|
||||||
|
case fragment.type
|
||||||
|
when ListBase::BULLET, ListBase::NUMBER
|
||||||
|
annotate("<li>")
|
||||||
|
|
||||||
|
when ListBase::UPPERALPHA
|
||||||
|
annotate("<li type=\"A\">")
|
||||||
|
|
||||||
|
when ListBase::LOWERALPHA
|
||||||
|
annotate("<li type=\"a\">")
|
||||||
|
|
||||||
|
when ListBase::LABELED
|
||||||
|
annotate("<dt>") +
|
||||||
|
convert_flow(am.flow(fragment.param)) +
|
||||||
|
annotate("</dt>") +
|
||||||
|
annotate("<dd>")
|
||||||
|
|
||||||
|
when ListBase::NOTE
|
||||||
|
annotate("<tr>") +
|
||||||
|
annotate("<td valign=\"top\">") +
|
||||||
|
convert_flow(am.flow(fragment.param)) +
|
||||||
|
annotate("</td>") +
|
||||||
|
annotate("<td>")
|
||||||
|
else
|
||||||
|
raise "Invalid list type"
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
def list_end_for(fragment_type)
|
||||||
|
case fragment_type
|
||||||
|
when ListBase::BULLET, ListBase::NUMBER, ListBase::UPPERALPHA, ListBase::LOWERALPHA
|
||||||
|
"</li>"
|
||||||
|
when ListBase::LABELED
|
||||||
|
"</dd>"
|
||||||
|
when ListBase::NOTE
|
||||||
|
"</td></tr>"
|
||||||
|
else
|
||||||
|
raise "Invalid list type"
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
end
|
||||||
|
|
||||||
|
end
|
||||||
333
lib/rdoc/markup/simple_markup/to_latex.rb
Normal file
333
lib/rdoc/markup/simple_markup/to_latex.rb
Normal file
|
|
@ -0,0 +1,333 @@
|
||||||
|
require 'rdoc/markup/simple_markup/fragments'
|
||||||
|
require 'rdoc/markup/simple_markup/inline'
|
||||||
|
|
||||||
|
require 'cgi'
|
||||||
|
|
||||||
|
module SM
|
||||||
|
|
||||||
|
# Convert SimpleMarkup to basic LaTeX report format
|
||||||
|
|
||||||
|
class ToLaTeX
|
||||||
|
|
||||||
|
BS = "\020" # \
|
||||||
|
OB = "\021" # {
|
||||||
|
CB = "\022" # }
|
||||||
|
DL = "\023" # Dollar
|
||||||
|
|
||||||
|
BACKSLASH = "#{BS}symbol#{OB}92#{CB}"
|
||||||
|
HAT = "#{BS}symbol#{OB}94#{CB}"
|
||||||
|
BACKQUOTE = "#{BS}symbol#{OB}0#{CB}"
|
||||||
|
TILDE = "#{DL}#{BS}sim#{DL}"
|
||||||
|
LESSTHAN = "#{DL}<#{DL}"
|
||||||
|
GREATERTHAN = "#{DL}>#{DL}"
|
||||||
|
|
||||||
|
def self.l(str)
|
||||||
|
str.tr('\\', BS).tr('{', OB).tr('}', CB).tr('$', DL)
|
||||||
|
end
|
||||||
|
|
||||||
|
def l(arg)
|
||||||
|
SM::ToLaTeX.l(arg)
|
||||||
|
end
|
||||||
|
|
||||||
|
LIST_TYPE_TO_LATEX = {
|
||||||
|
ListBase::BULLET => [ l("\\begin{itemize}"), l("\\end{itemize}") ],
|
||||||
|
ListBase::NUMBER => [ l("\\begin{enumerate}"), l("\\end{enumerate}"), "\\arabic" ],
|
||||||
|
ListBase::UPPERALPHA => [ l("\\begin{enumerate}"), l("\\end{enumerate}"), "\\Alph" ],
|
||||||
|
ListBase::LOWERALPHA => [ l("\\begin{enumerate}"), l("\\end{enumerate}"), "\\alph" ],
|
||||||
|
ListBase::LABELED => [ l("\\begin{description}"), l("\\end{description}") ],
|
||||||
|
ListBase::NOTE => [
|
||||||
|
l("\\begin{tabularx}{\\linewidth}{@{} l X @{}}"),
|
||||||
|
l("\\end{tabularx}") ],
|
||||||
|
}
|
||||||
|
|
||||||
|
InlineTag = Struct.new(:bit, :on, :off)
|
||||||
|
|
||||||
|
def initialize
|
||||||
|
init_tags
|
||||||
|
@list_depth = 0
|
||||||
|
@prev_list_types = []
|
||||||
|
end
|
||||||
|
|
||||||
|
##
|
||||||
|
# Set up the standard mapping of attributes to LaTeX
|
||||||
|
#
|
||||||
|
def init_tags
|
||||||
|
@attr_tags = [
|
||||||
|
InlineTag.new(SM::Attribute.bitmap_for(:BOLD), l("\\textbf{"), l("}")),
|
||||||
|
InlineTag.new(SM::Attribute.bitmap_for(:TT), l("\\texttt{"), l("}")),
|
||||||
|
InlineTag.new(SM::Attribute.bitmap_for(:EM), l("\\emph{"), l("}")),
|
||||||
|
]
|
||||||
|
end
|
||||||
|
|
||||||
|
##
|
||||||
|
# Escape a LaTeX string
|
||||||
|
def escape(str)
|
||||||
|
# $stderr.print "FE: ", str
|
||||||
|
s = str.
|
||||||
|
# sub(/\s+$/, '').
|
||||||
|
gsub(/([_\${}&%#])/, "#{BS}\\1").
|
||||||
|
gsub(/\\/, BACKSLASH).
|
||||||
|
gsub(/\^/, HAT).
|
||||||
|
gsub(/~/, TILDE).
|
||||||
|
gsub(/</, LESSTHAN).
|
||||||
|
gsub(/>/, GREATERTHAN).
|
||||||
|
gsub(/,,/, ",{},").
|
||||||
|
gsub(/\`/, BACKQUOTE)
|
||||||
|
# $stderr.print "-> ", s, "\n"
|
||||||
|
s
|
||||||
|
end
|
||||||
|
|
||||||
|
##
|
||||||
|
# Add a new set of LaTeX tags for an attribute. We allow
|
||||||
|
# separate start and end tags for flexibility
|
||||||
|
#
|
||||||
|
def add_tag(name, start, stop)
|
||||||
|
@attr_tags << InlineTag.new(SM::Attribute.bitmap_for(name), start, stop)
|
||||||
|
end
|
||||||
|
|
||||||
|
|
||||||
|
##
|
||||||
|
# Here's the client side of the visitor pattern
|
||||||
|
|
||||||
|
def start_accepting
|
||||||
|
@res = ""
|
||||||
|
@in_list_entry = []
|
||||||
|
end
|
||||||
|
|
||||||
|
def end_accepting
|
||||||
|
@res.tr(BS, '\\').tr(OB, '{').tr(CB, '}').tr(DL, '$')
|
||||||
|
end
|
||||||
|
|
||||||
|
def accept_paragraph(am, fragment)
|
||||||
|
@res << wrap(convert_flow(am.flow(fragment.txt)))
|
||||||
|
@res << "\n"
|
||||||
|
end
|
||||||
|
|
||||||
|
def accept_verbatim(am, fragment)
|
||||||
|
@res << "\n\\begin{code}\n"
|
||||||
|
@res << fragment.txt.sub(/[\n\s]+\Z/, '')
|
||||||
|
@res << "\n\\end{code}\n\n"
|
||||||
|
end
|
||||||
|
|
||||||
|
def accept_rule(am, fragment)
|
||||||
|
size = fragment.param
|
||||||
|
size = 10 if size > 10
|
||||||
|
@res << "\n\n\\rule{\\linewidth}{#{size}pt}\n\n"
|
||||||
|
end
|
||||||
|
|
||||||
|
def accept_list_start(am, fragment)
|
||||||
|
@res << list_name(fragment.type, true) <<"\n"
|
||||||
|
@in_list_entry.push false
|
||||||
|
end
|
||||||
|
|
||||||
|
def accept_list_end(am, fragment)
|
||||||
|
if tag = @in_list_entry.pop
|
||||||
|
@res << tag << "\n"
|
||||||
|
end
|
||||||
|
@res << list_name(fragment.type, false) <<"\n"
|
||||||
|
end
|
||||||
|
|
||||||
|
def accept_list_item(am, fragment)
|
||||||
|
if tag = @in_list_entry.last
|
||||||
|
@res << tag << "\n"
|
||||||
|
end
|
||||||
|
@res << list_item_start(am, fragment)
|
||||||
|
@res << wrap(convert_flow(am.flow(fragment.txt))) << "\n"
|
||||||
|
@in_list_entry[-1] = list_end_for(fragment.type)
|
||||||
|
end
|
||||||
|
|
||||||
|
def accept_blank_line(am, fragment)
|
||||||
|
# @res << "\n"
|
||||||
|
end
|
||||||
|
|
||||||
|
def accept_heading(am, fragment)
|
||||||
|
@res << convert_heading(fragment.head_level, am.flow(fragment.txt))
|
||||||
|
end
|
||||||
|
|
||||||
|
# This is a higher speed (if messier) version of wrap
|
||||||
|
|
||||||
|
def wrap(txt, line_len = 76)
|
||||||
|
res = ""
|
||||||
|
sp = 0
|
||||||
|
ep = txt.length
|
||||||
|
while sp < ep
|
||||||
|
# scan back for a space
|
||||||
|
p = sp + line_len - 1
|
||||||
|
if p >= ep
|
||||||
|
p = ep
|
||||||
|
else
|
||||||
|
while p > sp and txt[p] != ?\s
|
||||||
|
p -= 1
|
||||||
|
end
|
||||||
|
if p <= sp
|
||||||
|
p = sp + line_len
|
||||||
|
while p < ep and txt[p] != ?\s
|
||||||
|
p += 1
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
res << txt[sp...p] << "\n"
|
||||||
|
sp = p
|
||||||
|
sp += 1 while sp < ep and txt[sp] == ?\s
|
||||||
|
end
|
||||||
|
res
|
||||||
|
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 << 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 << tag.off
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
def convert_flow(flow)
|
||||||
|
res = ""
|
||||||
|
flow.each do |item|
|
||||||
|
case item
|
||||||
|
when String
|
||||||
|
# $stderr.puts "Converting '#{item}'"
|
||||||
|
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
|
||||||
|
|
||||||
|
# some of these patterns are taken from SmartyPants...
|
||||||
|
|
||||||
|
def convert_string(item)
|
||||||
|
|
||||||
|
escape(item).
|
||||||
|
|
||||||
|
|
||||||
|
# convert ... to elipsis (and make sure .... becomes .<elipsis>)
|
||||||
|
gsub(/\.\.\.\./, '.\ldots{}').gsub(/\.\.\./, '\ldots{}').
|
||||||
|
|
||||||
|
# convert single closing quote
|
||||||
|
gsub(%r{([^ \t\r\n\[\{\(])\'}) { "#$1'" }.
|
||||||
|
gsub(%r{\'(?=\W|s\b)}) { "'" }.
|
||||||
|
|
||||||
|
# convert single opening quote
|
||||||
|
gsub(/'/, '`').
|
||||||
|
|
||||||
|
# convert double closing quote
|
||||||
|
gsub(%r{([^ \t\r\n\[\{\(])\"(?=\W)}) { "#$1''" }.
|
||||||
|
|
||||||
|
# convert double opening quote
|
||||||
|
gsub(/"/, "``").
|
||||||
|
|
||||||
|
# convert copyright
|
||||||
|
gsub(/\(c\)/, '\copyright{}')
|
||||||
|
|
||||||
|
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
|
||||||
|
|
||||||
|
def convert_heading(level, flow)
|
||||||
|
res =
|
||||||
|
case level
|
||||||
|
when 1 then "\\chapter{"
|
||||||
|
when 2 then "\\section{"
|
||||||
|
when 3 then "\\subsection{"
|
||||||
|
when 4 then "\\subsubsection{"
|
||||||
|
else "\\paragraph{"
|
||||||
|
end +
|
||||||
|
convert_flow(flow) +
|
||||||
|
"}\n"
|
||||||
|
end
|
||||||
|
|
||||||
|
def list_name(list_type, is_open_tag)
|
||||||
|
tags = LIST_TYPE_TO_LATEX[list_type] || raise("Invalid list type: #{list_type.inspect}")
|
||||||
|
if tags[2] # enumerate
|
||||||
|
if is_open_tag
|
||||||
|
@list_depth += 1
|
||||||
|
if @prev_list_types[@list_depth] != tags[2]
|
||||||
|
case @list_depth
|
||||||
|
when 1
|
||||||
|
roman = "i"
|
||||||
|
when 2
|
||||||
|
roman = "ii"
|
||||||
|
when 3
|
||||||
|
roman = "iii"
|
||||||
|
when 4
|
||||||
|
roman = "iv"
|
||||||
|
else
|
||||||
|
raise("Too deep list: level #{@list_depth}")
|
||||||
|
end
|
||||||
|
@prev_list_types[@list_depth] = tags[2]
|
||||||
|
return l("\\renewcommand{\\labelenum#{roman}}{#{tags[2]}{enum#{roman}}}") + "\n" + tags[0]
|
||||||
|
end
|
||||||
|
else
|
||||||
|
@list_depth -= 1
|
||||||
|
end
|
||||||
|
end
|
||||||
|
tags[ is_open_tag ? 0 : 1]
|
||||||
|
end
|
||||||
|
|
||||||
|
def list_item_start(am, fragment)
|
||||||
|
case fragment.type
|
||||||
|
when ListBase::BULLET, ListBase::NUMBER, ListBase::UPPERALPHA, ListBase::LOWERALPHA
|
||||||
|
"\\item "
|
||||||
|
|
||||||
|
when ListBase::LABELED
|
||||||
|
"\\item[" + convert_flow(am.flow(fragment.param)) + "] "
|
||||||
|
|
||||||
|
when ListBase::NOTE
|
||||||
|
convert_flow(am.flow(fragment.param)) + " & "
|
||||||
|
else
|
||||||
|
raise "Invalid list type"
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
def list_end_for(fragment_type)
|
||||||
|
case fragment_type
|
||||||
|
when ListBase::BULLET, ListBase::NUMBER, ListBase::UPPERALPHA, ListBase::LOWERALPHA, ListBase::LABELED
|
||||||
|
""
|
||||||
|
when ListBase::NOTE
|
||||||
|
"\\\\\n"
|
||||||
|
else
|
||||||
|
raise "Invalid list type"
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
end
|
||||||
|
|
||||||
|
end
|
||||||
2
lib/rdoc/markup/test/AllTests.rb
Normal file
2
lib/rdoc/markup/test/AllTests.rb
Normal file
|
|
@ -0,0 +1,2 @@
|
||||||
|
require 'TestParse.rb'
|
||||||
|
require 'TestInline.rb'
|
||||||
151
lib/rdoc/markup/test/TestInline.rb
Normal file
151
lib/rdoc/markup/test/TestInline.rb
Normal file
|
|
@ -0,0 +1,151 @@
|
||||||
|
require "test/unit"
|
||||||
|
|
||||||
|
$:.unshift "../../.."
|
||||||
|
|
||||||
|
require "rdoc/markup/simple_markup/inline"
|
||||||
|
|
||||||
|
class TestInline < Test::Unit::TestCase
|
||||||
|
|
||||||
|
|
||||||
|
def setup
|
||||||
|
@am = SM::AttributeManager.new
|
||||||
|
|
||||||
|
@bold_on = @am.changed_attribute_by_name([], [:BOLD])
|
||||||
|
@bold_off = @am.changed_attribute_by_name([:BOLD], [])
|
||||||
|
|
||||||
|
@tt_on = @am.changed_attribute_by_name([], [:TT])
|
||||||
|
@tt_off = @am.changed_attribute_by_name([:TT], [])
|
||||||
|
|
||||||
|
@em_on = @am.changed_attribute_by_name([], [:EM])
|
||||||
|
@em_off = @am.changed_attribute_by_name([:EM], [])
|
||||||
|
|
||||||
|
@bold_em_on = @am.changed_attribute_by_name([], [:BOLD] | [:EM])
|
||||||
|
@bold_em_off = @am.changed_attribute_by_name([:BOLD] | [:EM], [])
|
||||||
|
|
||||||
|
@em_then_bold = @am.changed_attribute_by_name([:EM], [:EM] | [:BOLD])
|
||||||
|
|
||||||
|
@em_to_bold = @am.changed_attribute_by_name([:EM], [:BOLD])
|
||||||
|
|
||||||
|
@am.add_word_pair("{", "}", :WOMBAT)
|
||||||
|
@wombat_on = @am.changed_attribute_by_name([], [:WOMBAT])
|
||||||
|
@wombat_off = @am.changed_attribute_by_name([:WOMBAT], [])
|
||||||
|
end
|
||||||
|
|
||||||
|
def crossref(text)
|
||||||
|
[ @am.changed_attribute_by_name([], [:CROSSREF] | [:_SPECIAL_]),
|
||||||
|
SM::Special.new(33, text),
|
||||||
|
@am.changed_attribute_by_name([:CROSSREF] | [:_SPECIAL_], [])
|
||||||
|
]
|
||||||
|
end
|
||||||
|
|
||||||
|
def test_special
|
||||||
|
# class names, variable names, file names, or instance variables
|
||||||
|
@am.add_special(/(
|
||||||
|
\b([A-Z]\w+(::\w+)*)
|
||||||
|
| \#\w+[!?=]?
|
||||||
|
| \b\w+([_\/\.]+\w+)+[!?=]?
|
||||||
|
)/x,
|
||||||
|
:CROSSREF)
|
||||||
|
|
||||||
|
assert_equal(["cat"], @am.flow("cat"))
|
||||||
|
|
||||||
|
assert_equal(["cat ", crossref("#fred"), " dog"].flatten,
|
||||||
|
@am.flow("cat #fred dog"))
|
||||||
|
|
||||||
|
assert_equal([crossref("#fred"), " dog"].flatten,
|
||||||
|
@am.flow("#fred dog"))
|
||||||
|
|
||||||
|
assert_equal(["cat ", crossref("#fred")].flatten, @am.flow("cat #fred"))
|
||||||
|
end
|
||||||
|
|
||||||
|
def test_basic
|
||||||
|
assert_equal(["cat"], @am.flow("cat"))
|
||||||
|
|
||||||
|
assert_equal(["cat ", @bold_on, "and", @bold_off, " dog"],
|
||||||
|
@am.flow("cat *and* dog"))
|
||||||
|
|
||||||
|
assert_equal(["cat ", @bold_on, "AND", @bold_off, " dog"],
|
||||||
|
@am.flow("cat *AND* dog"))
|
||||||
|
|
||||||
|
assert_equal(["cat ", @em_on, "And", @em_off, " dog"],
|
||||||
|
@am.flow("cat _And_ dog"))
|
||||||
|
|
||||||
|
assert_equal(["cat *and dog*"], @am.flow("cat *and dog*"))
|
||||||
|
|
||||||
|
assert_equal(["*cat and* dog"], @am.flow("*cat and* dog"))
|
||||||
|
|
||||||
|
assert_equal(["cat *and ", @bold_on, "dog", @bold_off],
|
||||||
|
@am.flow("cat *and *dog*"))
|
||||||
|
|
||||||
|
assert_equal(["cat ", @em_on, "and", @em_off, " dog"],
|
||||||
|
@am.flow("cat _and_ dog"))
|
||||||
|
|
||||||
|
assert_equal(["cat_and_dog"],
|
||||||
|
@am.flow("cat_and_dog"))
|
||||||
|
|
||||||
|
assert_equal(["cat ", @tt_on, "and", @tt_off, " dog"],
|
||||||
|
@am.flow("cat +and+ dog"))
|
||||||
|
|
||||||
|
assert_equal(["cat ", @bold_on, "a_b_c", @bold_off, " dog"],
|
||||||
|
@am.flow("cat *a_b_c* dog"))
|
||||||
|
|
||||||
|
assert_equal(["cat __ dog"],
|
||||||
|
@am.flow("cat __ dog"))
|
||||||
|
|
||||||
|
assert_equal(["cat ", @em_on, "_", @em_off, " dog"],
|
||||||
|
@am.flow("cat ___ dog"))
|
||||||
|
|
||||||
|
end
|
||||||
|
|
||||||
|
def test_combined
|
||||||
|
assert_equal(["cat ", @em_on, "and", @em_off, " ", @bold_on, "dog", @bold_off],
|
||||||
|
@am.flow("cat _and_ *dog*"))
|
||||||
|
|
||||||
|
assert_equal(["cat ", @em_on, "a__nd", @em_off, " ", @bold_on, "dog", @bold_off],
|
||||||
|
@am.flow("cat _a__nd_ *dog*"))
|
||||||
|
end
|
||||||
|
|
||||||
|
def test_html_like
|
||||||
|
assert_equal(["cat ", @tt_on, "dog", @tt_off], @am.flow("cat <tt>dog</Tt>"))
|
||||||
|
|
||||||
|
assert_equal(["cat ", @em_on, "and", @em_off, " ", @bold_on, "dog", @bold_off],
|
||||||
|
@am.flow("cat <i>and</i> <B>dog</b>"))
|
||||||
|
|
||||||
|
assert_equal(["cat ", @em_on, "and ", @em_then_bold, "dog", @bold_em_off],
|
||||||
|
@am.flow("cat <i>and <B>dog</B></I>"))
|
||||||
|
|
||||||
|
assert_equal(["cat ", @em_on, "and ", @em_to_bold, "dog", @bold_off],
|
||||||
|
@am.flow("cat <i>and </i><b>dog</b>"))
|
||||||
|
|
||||||
|
assert_equal(["cat ", @em_on, "and ", @em_to_bold, "dog", @bold_off],
|
||||||
|
@am.flow("cat <i>and <b></i>dog</b>"))
|
||||||
|
|
||||||
|
assert_equal([@tt_on, "cat", @tt_off, " ", @em_on, "and ", @em_to_bold, "dog", @bold_off],
|
||||||
|
@am.flow("<tt>cat</tt> <i>and <b></i>dog</b>"))
|
||||||
|
|
||||||
|
assert_equal(["cat ", @em_on, "and ", @em_then_bold, "dog", @bold_em_off],
|
||||||
|
@am.flow("cat <i>and <b>dog</b></i>"))
|
||||||
|
|
||||||
|
assert_equal(["cat ", @bold_em_on, "and", @bold_em_off, " dog"],
|
||||||
|
@am.flow("cat <i><b>and</b></i> dog"))
|
||||||
|
|
||||||
|
|
||||||
|
end
|
||||||
|
|
||||||
|
def test_protect
|
||||||
|
assert_equal(['cat \\ dog'], @am.flow('cat \\ dog'))
|
||||||
|
|
||||||
|
assert_equal(["cat <tt>dog</Tt>"], @am.flow("cat \\<tt>dog</Tt>"))
|
||||||
|
|
||||||
|
assert_equal(["cat ", @em_on, "and", @em_off, " <B>dog</b>"],
|
||||||
|
@am.flow("cat <i>and</i> \\<B>dog</b>"))
|
||||||
|
|
||||||
|
assert_equal(["*word* or <b>text</b>"], @am.flow("\\*word* or \\<b>text</b>"))
|
||||||
|
end
|
||||||
|
|
||||||
|
def test_adding
|
||||||
|
assert_equal(["cat ", @wombat_on, "and", @wombat_off, " dog" ],
|
||||||
|
@am.flow("cat {and} dog"))
|
||||||
|
# assert_equal(["cat {and} dog" ], @am.flow("cat \\{and} dog"))
|
||||||
|
end
|
||||||
|
end
|
||||||
503
lib/rdoc/markup/test/TestParse.rb
Normal file
503
lib/rdoc/markup/test/TestParse.rb
Normal file
|
|
@ -0,0 +1,503 @@
|
||||||
|
require 'test/unit'
|
||||||
|
|
||||||
|
$:.unshift "../../.."
|
||||||
|
|
||||||
|
require 'rdoc/markup/simple_markup'
|
||||||
|
|
||||||
|
include SM
|
||||||
|
|
||||||
|
class TestParse < Test::Unit::TestCase
|
||||||
|
|
||||||
|
class MockOutput
|
||||||
|
def start_accepting
|
||||||
|
@res = []
|
||||||
|
end
|
||||||
|
|
||||||
|
def end_accepting
|
||||||
|
@res
|
||||||
|
end
|
||||||
|
|
||||||
|
def accept_paragraph(am, fragment)
|
||||||
|
@res << fragment.to_s
|
||||||
|
end
|
||||||
|
|
||||||
|
def accept_verbatim(am, fragment)
|
||||||
|
@res << fragment.to_s
|
||||||
|
end
|
||||||
|
|
||||||
|
def accept_list_start(am, fragment)
|
||||||
|
@res << fragment.to_s
|
||||||
|
end
|
||||||
|
|
||||||
|
def accept_list_end(am, fragment)
|
||||||
|
@res << fragment.to_s
|
||||||
|
end
|
||||||
|
|
||||||
|
def accept_list_item(am, fragment)
|
||||||
|
@res << fragment.to_s
|
||||||
|
end
|
||||||
|
|
||||||
|
def accept_blank_line(am, fragment)
|
||||||
|
@res << fragment.to_s
|
||||||
|
end
|
||||||
|
|
||||||
|
def accept_heading(am, fragment)
|
||||||
|
@res << fragment.to_s
|
||||||
|
end
|
||||||
|
|
||||||
|
def accept_rule(am, fragment)
|
||||||
|
@res << fragment.to_s
|
||||||
|
end
|
||||||
|
|
||||||
|
end
|
||||||
|
|
||||||
|
def basic_conv(str)
|
||||||
|
sm = SimpleMarkup.new
|
||||||
|
mock = MockOutput.new
|
||||||
|
sm.convert(str, mock)
|
||||||
|
sm.content
|
||||||
|
end
|
||||||
|
|
||||||
|
def line_types(str, expected)
|
||||||
|
p = SimpleMarkup.new
|
||||||
|
mock = MockOutput.new
|
||||||
|
p.convert(str, mock)
|
||||||
|
assert_equal(expected, p.get_line_types.map{|type| type.to_s[0,1]}.join(''))
|
||||||
|
end
|
||||||
|
|
||||||
|
def line_groups(str, expected)
|
||||||
|
p = SimpleMarkup.new
|
||||||
|
mock = MockOutput.new
|
||||||
|
|
||||||
|
block = p.convert(str, mock)
|
||||||
|
|
||||||
|
if block != expected
|
||||||
|
rows = (0...([expected.size, block.size].max)).collect{|i|
|
||||||
|
[expected[i]||"nil", block[i]||"nil"]
|
||||||
|
}
|
||||||
|
printf "\n\n%35s %35s\n", "Expected", "Got"
|
||||||
|
rows.each {|e,g| printf "%35s %35s\n", e.dump, g.dump }
|
||||||
|
end
|
||||||
|
|
||||||
|
assert_equal(expected, block)
|
||||||
|
end
|
||||||
|
|
||||||
|
def test_tabs
|
||||||
|
str = "hello\n dave"
|
||||||
|
assert_equal(str, basic_conv(str))
|
||||||
|
str = "hello\n\tdave"
|
||||||
|
assert_equal("hello\n dave", basic_conv(str))
|
||||||
|
str = "hello\n \tdave"
|
||||||
|
assert_equal("hello\n dave", basic_conv(str))
|
||||||
|
str = "hello\n \tdave"
|
||||||
|
assert_equal("hello\n dave", basic_conv(str))
|
||||||
|
str = "hello\n \tdave"
|
||||||
|
assert_equal("hello\n dave", basic_conv(str))
|
||||||
|
str = "hello\n \tdave"
|
||||||
|
assert_equal("hello\n dave", basic_conv(str))
|
||||||
|
str = "hello\n \tdave"
|
||||||
|
assert_equal("hello\n dave", basic_conv(str))
|
||||||
|
str = "hello\n \tdave"
|
||||||
|
assert_equal("hello\n dave", basic_conv(str))
|
||||||
|
str = "hello\n \tdave"
|
||||||
|
assert_equal("hello\n dave", basic_conv(str))
|
||||||
|
str = "hello\n \tdave"
|
||||||
|
assert_equal("hello\n dave", basic_conv(str))
|
||||||
|
str = ".\t\t."
|
||||||
|
assert_equal(". .", basic_conv(str))
|
||||||
|
end
|
||||||
|
|
||||||
|
def test_whitespace
|
||||||
|
assert_equal("hello", basic_conv("hello"))
|
||||||
|
assert_equal("hello", basic_conv(" hello "))
|
||||||
|
assert_equal("hello", basic_conv(" \t \t hello\t\t"))
|
||||||
|
|
||||||
|
assert_equal("1\n 2\n 3", basic_conv("1\n 2\n 3"))
|
||||||
|
assert_equal("1\n 2\n 3", basic_conv(" 1\n 2\n 3"))
|
||||||
|
|
||||||
|
assert_equal("1\n 2\n 3\n1\n 2", basic_conv("1\n 2\n 3\n1\n 2"))
|
||||||
|
assert_equal("1\n 2\n 3\n1\n 2", basic_conv(" 1\n 2\n 3\n 1\n 2"))
|
||||||
|
|
||||||
|
assert_equal("1\n 2\n\n 3", basic_conv(" 1\n 2\n\n 3"))
|
||||||
|
end
|
||||||
|
|
||||||
|
def test_types
|
||||||
|
str = "now is the time"
|
||||||
|
line_types(str, 'P')
|
||||||
|
|
||||||
|
str = "now is the time\nfor all good men"
|
||||||
|
line_types(str, 'PP')
|
||||||
|
|
||||||
|
str = "now is the time\n code\nfor all good men"
|
||||||
|
line_types(str, 'PVP')
|
||||||
|
|
||||||
|
str = "now is the time\n code\n more code\nfor all good men"
|
||||||
|
line_types(str, 'PVVP')
|
||||||
|
|
||||||
|
str = "now is\n---\nthe time"
|
||||||
|
line_types(str, 'PRP')
|
||||||
|
|
||||||
|
str = %{\
|
||||||
|
now is
|
||||||
|
* l1
|
||||||
|
* l2
|
||||||
|
the time}
|
||||||
|
line_types(str, 'PLLP')
|
||||||
|
|
||||||
|
str = %{\
|
||||||
|
now is
|
||||||
|
* l1
|
||||||
|
l1+
|
||||||
|
* l2
|
||||||
|
the time}
|
||||||
|
line_types(str, 'PLPLP')
|
||||||
|
|
||||||
|
str = %{\
|
||||||
|
now is
|
||||||
|
* l1
|
||||||
|
* l1.1
|
||||||
|
* l2
|
||||||
|
the time}
|
||||||
|
line_types(str, 'PLLLP')
|
||||||
|
|
||||||
|
str = %{\
|
||||||
|
now is
|
||||||
|
* l1
|
||||||
|
* l1.1
|
||||||
|
text
|
||||||
|
code
|
||||||
|
code
|
||||||
|
|
||||||
|
text
|
||||||
|
* l2
|
||||||
|
the time}
|
||||||
|
line_types(str, 'PLLPVVBPLP')
|
||||||
|
|
||||||
|
str = %{\
|
||||||
|
now is
|
||||||
|
1. l1
|
||||||
|
* l1.1
|
||||||
|
2. l2
|
||||||
|
the time}
|
||||||
|
line_types(str, 'PLLLP')
|
||||||
|
|
||||||
|
str = %{\
|
||||||
|
now is
|
||||||
|
[cat] l1
|
||||||
|
* l1.1
|
||||||
|
[dog] l2
|
||||||
|
the time}
|
||||||
|
line_types(str, 'PLLLP')
|
||||||
|
|
||||||
|
str = %{\
|
||||||
|
now is
|
||||||
|
[cat] l1
|
||||||
|
continuation
|
||||||
|
[dog] l2
|
||||||
|
the time}
|
||||||
|
line_types(str, 'PLPLP')
|
||||||
|
end
|
||||||
|
|
||||||
|
def test_groups
|
||||||
|
str = "now is the time"
|
||||||
|
line_groups(str, ["L0: Paragraph\nnow is the time"] )
|
||||||
|
|
||||||
|
str = "now is the time\nfor all good men"
|
||||||
|
line_groups(str, ["L0: Paragraph\nnow is the time for all good men"] )
|
||||||
|
|
||||||
|
str = %{\
|
||||||
|
now is the time
|
||||||
|
code _line_ here
|
||||||
|
for all good men}
|
||||||
|
|
||||||
|
line_groups(str,
|
||||||
|
[ "L0: Paragraph\nnow is the time",
|
||||||
|
"L0: Verbatim\n code _line_ here\n",
|
||||||
|
"L0: Paragraph\nfor all good men"
|
||||||
|
] )
|
||||||
|
|
||||||
|
str = "now is the time\n code\n more code\nfor all good men"
|
||||||
|
line_groups(str,
|
||||||
|
[ "L0: Paragraph\nnow is the time",
|
||||||
|
"L0: Verbatim\n code\n more code\n",
|
||||||
|
"L0: Paragraph\nfor all good men"
|
||||||
|
] )
|
||||||
|
|
||||||
|
str = %{\
|
||||||
|
now is
|
||||||
|
* l1
|
||||||
|
* l2
|
||||||
|
the time}
|
||||||
|
line_groups(str,
|
||||||
|
[ "L0: Paragraph\nnow is",
|
||||||
|
"L1: ListStart\n",
|
||||||
|
"L1: ListItem\nl1",
|
||||||
|
"L1: ListItem\nl2",
|
||||||
|
"L1: ListEnd\n",
|
||||||
|
"L0: Paragraph\nthe time"
|
||||||
|
])
|
||||||
|
|
||||||
|
str = %{\
|
||||||
|
now is
|
||||||
|
* l1
|
||||||
|
l1+
|
||||||
|
* l2
|
||||||
|
the time}
|
||||||
|
line_groups(str,
|
||||||
|
[ "L0: Paragraph\nnow is",
|
||||||
|
"L1: ListStart\n",
|
||||||
|
"L1: ListItem\nl1 l1+",
|
||||||
|
"L1: ListItem\nl2",
|
||||||
|
"L1: ListEnd\n",
|
||||||
|
"L0: Paragraph\nthe time"
|
||||||
|
])
|
||||||
|
|
||||||
|
str = %{\
|
||||||
|
now is
|
||||||
|
* l1
|
||||||
|
* l1.1
|
||||||
|
* l2
|
||||||
|
the time}
|
||||||
|
line_groups(str,
|
||||||
|
[ "L0: Paragraph\nnow is",
|
||||||
|
"L1: ListStart\n",
|
||||||
|
"L1: ListItem\nl1",
|
||||||
|
"L2: ListStart\n",
|
||||||
|
"L2: ListItem\nl1.1",
|
||||||
|
"L2: ListEnd\n",
|
||||||
|
"L1: ListItem\nl2",
|
||||||
|
"L1: ListEnd\n",
|
||||||
|
"L0: Paragraph\nthe time"
|
||||||
|
])
|
||||||
|
|
||||||
|
|
||||||
|
str = %{\
|
||||||
|
now is
|
||||||
|
* l1
|
||||||
|
* l1.1
|
||||||
|
text
|
||||||
|
code
|
||||||
|
code
|
||||||
|
|
||||||
|
text
|
||||||
|
* l2
|
||||||
|
the time}
|
||||||
|
line_groups(str,
|
||||||
|
[ "L0: Paragraph\nnow is",
|
||||||
|
"L1: ListStart\n",
|
||||||
|
"L1: ListItem\nl1",
|
||||||
|
"L2: ListStart\n",
|
||||||
|
"L2: ListItem\nl1.1 text",
|
||||||
|
"L2: Verbatim\n code\n code\n",
|
||||||
|
"L2: Paragraph\ntext",
|
||||||
|
"L2: ListEnd\n",
|
||||||
|
"L1: ListItem\nl2",
|
||||||
|
"L1: ListEnd\n",
|
||||||
|
"L0: Paragraph\nthe time"
|
||||||
|
])
|
||||||
|
|
||||||
|
|
||||||
|
str = %{\
|
||||||
|
now is
|
||||||
|
1. l1
|
||||||
|
* l1.1
|
||||||
|
2. l2
|
||||||
|
the time}
|
||||||
|
line_groups(str,
|
||||||
|
[ "L0: Paragraph\nnow is",
|
||||||
|
"L1: ListStart\n",
|
||||||
|
"L1: ListItem\nl1",
|
||||||
|
"L2: ListStart\n",
|
||||||
|
"L2: ListItem\nl1.1",
|
||||||
|
"L2: ListEnd\n",
|
||||||
|
"L1: ListItem\nl2",
|
||||||
|
"L1: ListEnd\n",
|
||||||
|
"L0: Paragraph\nthe time"
|
||||||
|
])
|
||||||
|
|
||||||
|
str = %{\
|
||||||
|
now is
|
||||||
|
[cat] l1
|
||||||
|
* l1.1
|
||||||
|
[dog] l2
|
||||||
|
the time}
|
||||||
|
line_groups(str,
|
||||||
|
[ "L0: Paragraph\nnow is",
|
||||||
|
"L1: ListStart\n",
|
||||||
|
"L1: ListItem\nl1",
|
||||||
|
"L2: ListStart\n",
|
||||||
|
"L2: ListItem\nl1.1",
|
||||||
|
"L2: ListEnd\n",
|
||||||
|
"L1: ListItem\nl2",
|
||||||
|
"L1: ListEnd\n",
|
||||||
|
"L0: Paragraph\nthe time"
|
||||||
|
])
|
||||||
|
|
||||||
|
str = %{\
|
||||||
|
now is
|
||||||
|
[cat] l1
|
||||||
|
continuation
|
||||||
|
[dog] l2
|
||||||
|
the time}
|
||||||
|
line_groups(str,
|
||||||
|
[ "L0: Paragraph\nnow is",
|
||||||
|
"L1: ListStart\n",
|
||||||
|
"L1: ListItem\nl1 continuation",
|
||||||
|
"L1: ListItem\nl2",
|
||||||
|
"L1: ListEnd\n",
|
||||||
|
"L0: Paragraph\nthe time"
|
||||||
|
])
|
||||||
|
|
||||||
|
|
||||||
|
end
|
||||||
|
|
||||||
|
def test_verbatim_merge
|
||||||
|
str = %{\
|
||||||
|
now is
|
||||||
|
code
|
||||||
|
the time}
|
||||||
|
|
||||||
|
line_groups(str,
|
||||||
|
[ "L0: Paragraph\nnow is",
|
||||||
|
"L0: Verbatim\n code\n",
|
||||||
|
"L0: Paragraph\nthe time"
|
||||||
|
])
|
||||||
|
|
||||||
|
|
||||||
|
str = %{\
|
||||||
|
now is
|
||||||
|
code
|
||||||
|
code1
|
||||||
|
the time}
|
||||||
|
|
||||||
|
line_groups(str,
|
||||||
|
[ "L0: Paragraph\nnow is",
|
||||||
|
"L0: Verbatim\n code\n code1\n",
|
||||||
|
"L0: Paragraph\nthe time"
|
||||||
|
])
|
||||||
|
|
||||||
|
|
||||||
|
str = %{\
|
||||||
|
now is
|
||||||
|
code
|
||||||
|
|
||||||
|
code1
|
||||||
|
the time}
|
||||||
|
|
||||||
|
line_groups(str,
|
||||||
|
[ "L0: Paragraph\nnow is",
|
||||||
|
"L0: Verbatim\n code\n\n code1\n",
|
||||||
|
"L0: Paragraph\nthe time"
|
||||||
|
])
|
||||||
|
|
||||||
|
|
||||||
|
str = %{\
|
||||||
|
now is
|
||||||
|
code
|
||||||
|
|
||||||
|
code1
|
||||||
|
|
||||||
|
the time}
|
||||||
|
|
||||||
|
line_groups(str,
|
||||||
|
[ "L0: Paragraph\nnow is",
|
||||||
|
"L0: Verbatim\n code\n\n code1\n",
|
||||||
|
"L0: Paragraph\nthe time"
|
||||||
|
])
|
||||||
|
|
||||||
|
|
||||||
|
str = %{\
|
||||||
|
now is
|
||||||
|
code
|
||||||
|
|
||||||
|
code1
|
||||||
|
|
||||||
|
code2
|
||||||
|
the time}
|
||||||
|
|
||||||
|
line_groups(str,
|
||||||
|
[ "L0: Paragraph\nnow is",
|
||||||
|
"L0: Verbatim\n code\n\n code1\n\n code2\n",
|
||||||
|
"L0: Paragraph\nthe time"
|
||||||
|
])
|
||||||
|
|
||||||
|
|
||||||
|
# Folds multiple blank lines
|
||||||
|
str = %{\
|
||||||
|
now is
|
||||||
|
code
|
||||||
|
|
||||||
|
|
||||||
|
code1
|
||||||
|
|
||||||
|
the time}
|
||||||
|
|
||||||
|
line_groups(str,
|
||||||
|
[ "L0: Paragraph\nnow is",
|
||||||
|
"L0: Verbatim\n code\n\n code1\n",
|
||||||
|
"L0: Paragraph\nthe time"
|
||||||
|
])
|
||||||
|
|
||||||
|
|
||||||
|
end
|
||||||
|
|
||||||
|
def test_list_split
|
||||||
|
str = %{\
|
||||||
|
now is
|
||||||
|
* l1
|
||||||
|
1. n1
|
||||||
|
2. n2
|
||||||
|
* l2
|
||||||
|
the time}
|
||||||
|
line_groups(str,
|
||||||
|
[ "L0: Paragraph\nnow is",
|
||||||
|
"L1: ListStart\n",
|
||||||
|
"L1: ListItem\nl1",
|
||||||
|
"L1: ListEnd\n",
|
||||||
|
"L1: ListStart\n",
|
||||||
|
"L1: ListItem\nn1",
|
||||||
|
"L1: ListItem\nn2",
|
||||||
|
"L1: ListEnd\n",
|
||||||
|
"L1: ListStart\n",
|
||||||
|
"L1: ListItem\nl2",
|
||||||
|
"L1: ListEnd\n",
|
||||||
|
"L0: Paragraph\nthe time"
|
||||||
|
])
|
||||||
|
|
||||||
|
end
|
||||||
|
|
||||||
|
|
||||||
|
def test_headings
|
||||||
|
str = "= heading one"
|
||||||
|
line_groups(str,
|
||||||
|
[ "L0: Heading\nheading one"
|
||||||
|
])
|
||||||
|
|
||||||
|
str = "=== heading three"
|
||||||
|
line_groups(str,
|
||||||
|
[ "L0: Heading\nheading three"
|
||||||
|
])
|
||||||
|
|
||||||
|
str = "text\n === heading three"
|
||||||
|
line_groups(str,
|
||||||
|
[ "L0: Paragraph\ntext",
|
||||||
|
"L0: Verbatim\n === heading three\n"
|
||||||
|
])
|
||||||
|
|
||||||
|
str = "text\n code\n === heading three"
|
||||||
|
line_groups(str,
|
||||||
|
[ "L0: Paragraph\ntext",
|
||||||
|
"L0: Verbatim\n code\n === heading three\n"
|
||||||
|
])
|
||||||
|
|
||||||
|
str = "text\n code\n=== heading three"
|
||||||
|
line_groups(str,
|
||||||
|
[ "L0: Paragraph\ntext",
|
||||||
|
"L0: Verbatim\n code\n",
|
||||||
|
"L0: Heading\nheading three"
|
||||||
|
])
|
||||||
|
|
||||||
|
end
|
||||||
|
|
||||||
|
|
||||||
|
end
|
||||||
526
lib/rdoc/options.rb
Normal file
526
lib/rdoc/options.rb
Normal file
|
|
@ -0,0 +1,526 @@
|
||||||
|
# We handle the parsing of options, and subsequently as a singleton
|
||||||
|
# object to be queried for option values
|
||||||
|
|
||||||
|
class Options
|
||||||
|
|
||||||
|
require 'singleton'
|
||||||
|
require 'getoptlong'
|
||||||
|
|
||||||
|
include Singleton
|
||||||
|
|
||||||
|
# files matching this pattern will be excluded
|
||||||
|
attr_accessor :exclude
|
||||||
|
|
||||||
|
# the name of the output directory
|
||||||
|
attr_accessor :op_dir
|
||||||
|
|
||||||
|
# the name to use for the output
|
||||||
|
attr_reader :op_name
|
||||||
|
|
||||||
|
# include private and protected methods in the
|
||||||
|
# output
|
||||||
|
attr_accessor :show_all
|
||||||
|
|
||||||
|
# name of the file, class or module to display in
|
||||||
|
# the initial index page (if not specified
|
||||||
|
# the first file we encounter is used)
|
||||||
|
attr_accessor :main_page
|
||||||
|
|
||||||
|
# Don't display progress as we process the files
|
||||||
|
attr_reader :quiet
|
||||||
|
|
||||||
|
# description of the output generator (set with the <tt>-fmt</tt>
|
||||||
|
# option
|
||||||
|
attr_accessor :generator
|
||||||
|
|
||||||
|
# and the list of files to be processed
|
||||||
|
attr_reader :files
|
||||||
|
|
||||||
|
# array of directories to search for files to satisfy an :include:
|
||||||
|
attr_reader :rdoc_include
|
||||||
|
|
||||||
|
# title to be used out the output
|
||||||
|
#attr_writer :title
|
||||||
|
|
||||||
|
# template to be used when generating output
|
||||||
|
attr_reader :template
|
||||||
|
|
||||||
|
# should diagrams be drawn
|
||||||
|
attr_reader :diagram
|
||||||
|
|
||||||
|
# should we draw fileboxes in diagrams
|
||||||
|
attr_reader :fileboxes
|
||||||
|
|
||||||
|
# include the '#' at the front of hyperlinked instance method names
|
||||||
|
attr_reader :show_hash
|
||||||
|
|
||||||
|
# image format for diagrams
|
||||||
|
attr_reader :image_format
|
||||||
|
|
||||||
|
# character-set
|
||||||
|
attr_reader :charset
|
||||||
|
|
||||||
|
# should source code be included inline, or displayed in a popup
|
||||||
|
attr_reader :inline_source
|
||||||
|
|
||||||
|
# should the output be placed into a single file
|
||||||
|
attr_reader :all_one_file
|
||||||
|
|
||||||
|
# the number of columns in a tab
|
||||||
|
attr_reader :tab_width
|
||||||
|
|
||||||
|
# include line numbers in the source listings
|
||||||
|
attr_reader :include_line_numbers
|
||||||
|
|
||||||
|
# pattern for additional attr_... style methods
|
||||||
|
attr_reader :extra_accessors
|
||||||
|
attr_reader :extra_accessor_flags
|
||||||
|
|
||||||
|
# URL of stylesheet
|
||||||
|
attr_reader :css
|
||||||
|
|
||||||
|
# URL of web cvs frontend
|
||||||
|
attr_reader :webcvs
|
||||||
|
|
||||||
|
# Are we promiscuous about showing module contents across
|
||||||
|
# multiple files
|
||||||
|
attr_reader :promiscuous
|
||||||
|
|
||||||
|
module OptionList
|
||||||
|
|
||||||
|
OPTION_LIST = [
|
||||||
|
[ "--accessor", "-A", "accessorname[,..]",
|
||||||
|
"comma separated list of additional class methods\n" +
|
||||||
|
"that should be treated like 'attr_reader' and\n" +
|
||||||
|
"friends. Option may be repeated. Each accessorname\n" +
|
||||||
|
"may have '=text' appended, in which case that text\n" +
|
||||||
|
"appears where the r/w/rw appears for normal accessors."],
|
||||||
|
|
||||||
|
[ "--all", "-a", nil,
|
||||||
|
"include all methods (not just public)\nin the output" ],
|
||||||
|
|
||||||
|
[ "--charset", "-c", "charset",
|
||||||
|
"specifies HTML character-set" ],
|
||||||
|
|
||||||
|
[ "--debug", "-D", nil,
|
||||||
|
"displays lots on internal stuff" ],
|
||||||
|
|
||||||
|
[ "--diagram", "-d", nil,
|
||||||
|
"Generate diagrams showing modules and classes.\n" +
|
||||||
|
"You need dot V1.8.6 or later to use the --diagram\n" +
|
||||||
|
"option correctly. Dot is available from\n"+
|
||||||
|
"http://www.research.att.com/sw/tools/graphviz/" ],
|
||||||
|
|
||||||
|
[ "--exclude", "-x", "pattern",
|
||||||
|
"do not process files or directories matching\n" +
|
||||||
|
"pattern. Files given explicitly on the command\n" +
|
||||||
|
"line will never be excluded." ],
|
||||||
|
|
||||||
|
[ "--extension", "-E", "new=old",
|
||||||
|
"Treat files ending with .new as if they ended with\n" +
|
||||||
|
".old. Using '-E cgi=rb' will cause xxx.cgi to be\n" +
|
||||||
|
"parsed as a Ruby file"],
|
||||||
|
|
||||||
|
[ "--fileboxes", "-F", nil,
|
||||||
|
"classes are put in boxes which represents\n" +
|
||||||
|
"files, where these classes reside. Classes\n" +
|
||||||
|
"shared between more than one file are\n" +
|
||||||
|
"shown with list of files that sharing them.\n" +
|
||||||
|
"Silently discarded if --diagram is not given\n" +
|
||||||
|
"Experimental." ],
|
||||||
|
|
||||||
|
[ "--fmt", "-f", "format name",
|
||||||
|
"set the output formatter (see below)" ],
|
||||||
|
|
||||||
|
[ "--help", "-h", nil,
|
||||||
|
"you're looking at it" ],
|
||||||
|
|
||||||
|
[ "--help-output", "-O", nil,
|
||||||
|
"explain the various output options" ],
|
||||||
|
|
||||||
|
[ "--image-format", "-I", "gif/png/jpg/jpeg",
|
||||||
|
"Sets output image format for diagrams. Can\n" +
|
||||||
|
"be png, gif, jpeg, jpg. If this option is\n" +
|
||||||
|
"omitted, png is used. Requires --diagram." ],
|
||||||
|
|
||||||
|
[ "--include", "-i", "dir[,dir...]",
|
||||||
|
"set (or add to) the list of directories\n" +
|
||||||
|
"to be searched when satisfying :include:\n" +
|
||||||
|
"requests. Can be used more than once." ],
|
||||||
|
|
||||||
|
[ "--inline-source", "-S", nil,
|
||||||
|
"Show method source code inline, rather\n" +
|
||||||
|
"than via a popup link" ],
|
||||||
|
|
||||||
|
[ "--line-numbers", "-N", nil,
|
||||||
|
"Include line numbers in the source code" ],
|
||||||
|
|
||||||
|
[ "--main", "-m", "name",
|
||||||
|
"'name' will be the initial page displayed" ],
|
||||||
|
|
||||||
|
[ "--one-file", "-1", nil,
|
||||||
|
"put all the output into a single file" ],
|
||||||
|
|
||||||
|
[ "--op", "-o", "dir",
|
||||||
|
"set the output directory" ],
|
||||||
|
|
||||||
|
[ "--opname", "-n", "name",
|
||||||
|
"Set the 'name' of the output. Has no\n" +
|
||||||
|
"effect for HTML." ],
|
||||||
|
|
||||||
|
[ "--promiscuous", "-p", nil,
|
||||||
|
"When documenting a file that contains a module\n" +
|
||||||
|
"or class also defined in other files, show\n" +
|
||||||
|
"all stuff for that module/class in each files\n" +
|
||||||
|
"page. By default, only show stuff defined in\n" +
|
||||||
|
"that particular file." ],
|
||||||
|
|
||||||
|
[ "--quiet", "-q", nil,
|
||||||
|
"don't show progress as we parse" ],
|
||||||
|
|
||||||
|
[ "--show-hash", "-H", nil,
|
||||||
|
"A name of the form #name in a comment\n" +
|
||||||
|
"is a possible hyperlink to an instance\n" +
|
||||||
|
"method name. When displayed, the '#' is\n" +
|
||||||
|
"removed unless this option is specified" ],
|
||||||
|
|
||||||
|
[ "--style", "-s", "stylesheet url",
|
||||||
|
"specifies the URL of a separate stylesheet." ],
|
||||||
|
|
||||||
|
[ "--tab-width", "-w", "n",
|
||||||
|
"Set the width of tab characters (default 8)"],
|
||||||
|
|
||||||
|
[ "--template", "-T", "template name",
|
||||||
|
"Set the template used when generating output" ],
|
||||||
|
|
||||||
|
[ "--title", "-t", "text",
|
||||||
|
"Set 'txt' as the title for the output" ],
|
||||||
|
|
||||||
|
[ "--version", "-v", nil,
|
||||||
|
"display RDoc's version" ],
|
||||||
|
|
||||||
|
[ "--webcvs", "-W", "url",
|
||||||
|
"Specify a URL for linking to a web frontend\n" +
|
||||||
|
"to CVS. If the URL contains a '\%s', the\n" +
|
||||||
|
"name of the current file will be substituted;\n" +
|
||||||
|
"if the URL doesn't contain a '\%s', the\n" +
|
||||||
|
"filename will be appended to it." ],
|
||||||
|
]
|
||||||
|
|
||||||
|
def OptionList.options
|
||||||
|
OPTION_LIST.map do |long, short, arg,|
|
||||||
|
[ long,
|
||||||
|
short,
|
||||||
|
arg ? GetoptLong::REQUIRED_ARGUMENT : GetoptLong::NO_ARGUMENT
|
||||||
|
]
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
|
||||||
|
def OptionList.strip_output(text)
|
||||||
|
text =~ /^\s+/
|
||||||
|
leading_spaces = $&
|
||||||
|
text.gsub!(/^#{leading_spaces}/, '')
|
||||||
|
$stdout.puts text
|
||||||
|
end
|
||||||
|
|
||||||
|
|
||||||
|
# Show an error and exit
|
||||||
|
|
||||||
|
def OptionList.error(msg)
|
||||||
|
$stderr.puts
|
||||||
|
$stderr.puts msg
|
||||||
|
$stderr.puts "\nFor help on options, try 'rdoc --help'\n\n"
|
||||||
|
exit 1
|
||||||
|
end
|
||||||
|
|
||||||
|
# Show usage and exit
|
||||||
|
|
||||||
|
def OptionList.usage(generator_names)
|
||||||
|
|
||||||
|
puts
|
||||||
|
puts(VERSION_STRING)
|
||||||
|
puts
|
||||||
|
|
||||||
|
name = File.basename($0)
|
||||||
|
OptionList.strip_output(<<-EOT)
|
||||||
|
Usage:
|
||||||
|
|
||||||
|
#{name} [options] [names...]
|
||||||
|
|
||||||
|
Files are parsed, and the information they contain
|
||||||
|
collected, before any output is produced. This allows cross
|
||||||
|
references between all files to be resolved. If a name is a
|
||||||
|
directory, it is traversed. If no names are specified, all
|
||||||
|
Ruby files in the current directory (and subdirectories) are
|
||||||
|
processed.
|
||||||
|
|
||||||
|
Options:
|
||||||
|
|
||||||
|
EOT
|
||||||
|
|
||||||
|
OPTION_LIST.each do |long, short, arg, desc|
|
||||||
|
opt = sprintf("%20s", "#{long}, #{short}")
|
||||||
|
oparg = sprintf("%-7s", arg)
|
||||||
|
print "#{opt} #{oparg}"
|
||||||
|
desc = desc.split("\n")
|
||||||
|
if arg.nil? || arg.length < 7
|
||||||
|
puts desc.shift
|
||||||
|
else
|
||||||
|
puts
|
||||||
|
end
|
||||||
|
desc.each do |line|
|
||||||
|
puts(" "*28 + line)
|
||||||
|
end
|
||||||
|
puts
|
||||||
|
end
|
||||||
|
|
||||||
|
puts "\nAvailable output formatters: " +
|
||||||
|
generator_names.sort.join(', ') + "\n\n"
|
||||||
|
|
||||||
|
puts "For information on where the output goes, use\n\n"
|
||||||
|
puts " rdoc --help-output\n\n"
|
||||||
|
|
||||||
|
exit 0
|
||||||
|
end
|
||||||
|
|
||||||
|
def OptionList.help_output
|
||||||
|
OptionList.strip_output(<<-EOT)
|
||||||
|
How RDoc generates output depends on the output formatter being
|
||||||
|
used, and on the options you give.
|
||||||
|
|
||||||
|
- HTML output is normally produced into a number of separate files
|
||||||
|
(one per class, module, and file, along with various indices).
|
||||||
|
These files will appear in the directory given by the --op
|
||||||
|
option (doc/ by default).
|
||||||
|
|
||||||
|
- XML output by default is written to standard output. If a
|
||||||
|
--opname option is given, the output will instead be written
|
||||||
|
to a file with that name in the output directory.
|
||||||
|
|
||||||
|
- .chm files (Windows help files) are written in the --op directory.
|
||||||
|
If an --opname parameter is present, that name is used, otherwise
|
||||||
|
the file will be called rdoc.chm.
|
||||||
|
|
||||||
|
For information on other RDoc options, use "rdoc --help".
|
||||||
|
EOT
|
||||||
|
exit 0
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
# Parse command line options. We're passed a hash containing
|
||||||
|
# output generators, keyed by the generator name
|
||||||
|
|
||||||
|
def parse(argv, generators)
|
||||||
|
old_argv = ARGV.dup
|
||||||
|
begin
|
||||||
|
ARGV.replace(argv)
|
||||||
|
@op_dir = "doc"
|
||||||
|
@op_name = nil
|
||||||
|
@show_all = false
|
||||||
|
@main_page = nil
|
||||||
|
@exclude = nil
|
||||||
|
@quiet = false
|
||||||
|
@generator_name = 'html'
|
||||||
|
@generator = generators[@generator_name]
|
||||||
|
@rdoc_include = []
|
||||||
|
@title = nil
|
||||||
|
@template = nil
|
||||||
|
@diagram = false
|
||||||
|
@fileboxes = false
|
||||||
|
@show_hash = false
|
||||||
|
@image_format = 'png'
|
||||||
|
@inline_source = false
|
||||||
|
@all_one_file = false
|
||||||
|
@tab_width = 8
|
||||||
|
@include_line_numbers = false
|
||||||
|
@extra_accessor_flags = {}
|
||||||
|
@promiscuous = false
|
||||||
|
|
||||||
|
@css = nil
|
||||||
|
@webcvs = nil
|
||||||
|
|
||||||
|
@charset = case $KCODE
|
||||||
|
when /^S/i
|
||||||
|
'Shift_JIS'
|
||||||
|
when /^E/i
|
||||||
|
'EUC-JP'
|
||||||
|
else
|
||||||
|
'iso-8859-1'
|
||||||
|
end
|
||||||
|
|
||||||
|
accessors = []
|
||||||
|
|
||||||
|
go = GetoptLong.new(*OptionList.options)
|
||||||
|
go.quiet = true
|
||||||
|
|
||||||
|
go.each do |opt, arg|
|
||||||
|
case opt
|
||||||
|
when "--all" then @show_all = true
|
||||||
|
when "--charset" then @charset = arg
|
||||||
|
when "--debug" then $DEBUG = true
|
||||||
|
when "--exclude" then @exclude = Regexp.new(arg)
|
||||||
|
when "--inline-source" then @inline_source = true
|
||||||
|
when "--line-numbers" then @include_line_numbers = true
|
||||||
|
when "--main" then @main_page = arg
|
||||||
|
when "--one-file" then @all_one_file = true
|
||||||
|
when "--op" then @op_dir = arg
|
||||||
|
when "--opname" then @op_name = arg
|
||||||
|
when "--promiscuous" then @promiscuous = true
|
||||||
|
when "--quiet" then @quiet = true
|
||||||
|
when "--show-hash" then @show_hash = true
|
||||||
|
when "--style" then @css = arg
|
||||||
|
when "--template" then @template = arg
|
||||||
|
when "--title" then @title = arg
|
||||||
|
when "--webcvs" then @webcvs = arg
|
||||||
|
|
||||||
|
when "--accessor"
|
||||||
|
arg.split(/,/).each do |accessor|
|
||||||
|
if accessor =~ /^(\w+)(=(.*))?$/
|
||||||
|
accessors << $1
|
||||||
|
@extra_accessor_flags[$1] = $3
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
when "--diagram"
|
||||||
|
check_diagram
|
||||||
|
@diagram = true
|
||||||
|
|
||||||
|
when "--fileboxes"
|
||||||
|
@fileboxes = true if @diagram
|
||||||
|
|
||||||
|
when "--fmt"
|
||||||
|
@generator_name = arg.downcase
|
||||||
|
@generator = generators[@generator_name]
|
||||||
|
if !@generator
|
||||||
|
OptionList.error("Invalid output formatter")
|
||||||
|
end
|
||||||
|
|
||||||
|
if @generator_name == "xml"
|
||||||
|
@all_one_file = true
|
||||||
|
@inline_source = true
|
||||||
|
end
|
||||||
|
|
||||||
|
when "--help"
|
||||||
|
OptionList.usage(generators.keys)
|
||||||
|
|
||||||
|
when "--help-output"
|
||||||
|
OptionList.help_output
|
||||||
|
|
||||||
|
when "--image-format"
|
||||||
|
if ['gif', 'png', 'jpeg', 'jpg'].include?(arg)
|
||||||
|
@image_format = arg
|
||||||
|
else
|
||||||
|
raise GetoptLong::InvalidOption.new("unknown image format: #{arg}")
|
||||||
|
end
|
||||||
|
|
||||||
|
when "--include"
|
||||||
|
@rdoc_include.concat arg.split(/\s*,\s*/)
|
||||||
|
|
||||||
|
when "--tab-width"
|
||||||
|
begin
|
||||||
|
@tab_width = Integer(arg)
|
||||||
|
rescue
|
||||||
|
$stderr.puts "Invalid tab width: '#{arg}'"
|
||||||
|
exit 1
|
||||||
|
end
|
||||||
|
|
||||||
|
when "--extension"
|
||||||
|
new, old = arg.split(/=/, 2)
|
||||||
|
OptionList.error("Invalid parameter to '-E'") unless new && old
|
||||||
|
unless RDoc::ParserFactory.alias_extension(old, new)
|
||||||
|
OptionList.error("Unknown extension .#{old} to -E")
|
||||||
|
end
|
||||||
|
|
||||||
|
when "--version"
|
||||||
|
puts VERSION_STRING
|
||||||
|
exit
|
||||||
|
end
|
||||||
|
|
||||||
|
end
|
||||||
|
|
||||||
|
@files = ARGV.dup
|
||||||
|
|
||||||
|
@rdoc_include << "." if @rdoc_include.empty?
|
||||||
|
|
||||||
|
check_files
|
||||||
|
|
||||||
|
# If no template was specified, use the default
|
||||||
|
# template for the output formatter
|
||||||
|
|
||||||
|
@template ||= @generator_name
|
||||||
|
|
||||||
|
# Generate a regexp from the accessors
|
||||||
|
unless accessors.empty?
|
||||||
|
re = '^(' + accessors.map{|a| Regexp.quote(a)}.join('|') + ')$'
|
||||||
|
@extra_accessors = Regexp.new(re)
|
||||||
|
end
|
||||||
|
|
||||||
|
rescue GetoptLong::InvalidOption, GetoptLong::MissingArgument => error
|
||||||
|
OptionList.error(error.message)
|
||||||
|
|
||||||
|
ensure
|
||||||
|
ARGV.replace(old_argv)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
|
||||||
|
def title
|
||||||
|
@title ||= "RDoc Documentation"
|
||||||
|
end
|
||||||
|
|
||||||
|
# Set the title, but only if not already set. This means that a title set from
|
||||||
|
# the command line trumps one set in a source file
|
||||||
|
|
||||||
|
def title=(string)
|
||||||
|
@title ||= string
|
||||||
|
end
|
||||||
|
|
||||||
|
|
||||||
|
private
|
||||||
|
|
||||||
|
# Check that the right version of 'dot' is available.
|
||||||
|
# Unfortuately this doesn't work correctly under Windows NT,
|
||||||
|
# so we'll bypass the test under Windows
|
||||||
|
|
||||||
|
def check_diagram
|
||||||
|
return if RUBY_PLATFORM =~ /win/
|
||||||
|
|
||||||
|
ok = false
|
||||||
|
ver = nil
|
||||||
|
IO.popen("dot -V 2>&1") do |io|
|
||||||
|
ver = io.read
|
||||||
|
if ver =~ /dot\s+version(?:\s+gviz)?\s+(\d+)\.(\d+)/
|
||||||
|
ok = ($1.to_i > 1) || ($1.to_i == 1 && $2.to_i >= 8)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
unless ok
|
||||||
|
if ver =~ /^dot version/
|
||||||
|
$stderr.puts "Warning: You may need dot V1.8.6 or later to use\n",
|
||||||
|
"the --diagram option correctly. You have:\n\n ",
|
||||||
|
ver,
|
||||||
|
"\nDiagrams might have strange background colors.\n\n"
|
||||||
|
else
|
||||||
|
$stderr.puts "You need the 'dot' program to produce diagrams.",
|
||||||
|
"(see http://www.research.att.com/sw/tools/graphviz/)\n\n"
|
||||||
|
exit
|
||||||
|
end
|
||||||
|
# exit
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
# Check that the files on the command line exist
|
||||||
|
|
||||||
|
def check_files
|
||||||
|
@files.each do |f|
|
||||||
|
stat = File.stat f rescue error("File not found: #{f}")
|
||||||
|
error("File '#{f}' not readable") unless stat.readable?
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
def error(str)
|
||||||
|
$stderr.puts str
|
||||||
|
exit(1)
|
||||||
|
end
|
||||||
|
|
||||||
|
end
|
||||||
287
lib/rdoc/parsers/parse_c.rb
Normal file
287
lib/rdoc/parsers/parse_c.rb
Normal file
|
|
@ -0,0 +1,287 @@
|
||||||
|
# We attempt to parse C extension files. Basically we look for
|
||||||
|
# the standard patterns that you find in extensions: <tt>rb_define_class,
|
||||||
|
# rb_define_method</tt> and so on. We also try to find the corresponding
|
||||||
|
# C source for the methods and extract comments, but if we fail
|
||||||
|
# we don't worry too much.
|
||||||
|
#
|
||||||
|
# The comments associated with a Ruby method are extracted from the C
|
||||||
|
# comment block associated with the routine that _implements_ that
|
||||||
|
# method, that is to say the method whose name is given in the
|
||||||
|
# <tt>rb_define_method</tt> call. For example, you might write:
|
||||||
|
#
|
||||||
|
# /*
|
||||||
|
# * Returns a new array that is a one-dimensional flattening of this
|
||||||
|
# * array (recursively). That is, for every element that is an array,
|
||||||
|
# * extract its elements into the new array.
|
||||||
|
# *
|
||||||
|
# * s = [ 1, 2, 3 ] #=> [1, 2, 3]
|
||||||
|
# * t = [ 4, 5, 6, [7, 8] ] #=> [4, 5, 6, [7, 8]]
|
||||||
|
# * a = [ s, t, 9, 10 ] #=> [[1, 2, 3], [4, 5, 6, [7, 8]], 9, 10]
|
||||||
|
# * a.flatten #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
|
||||||
|
# */
|
||||||
|
# static VALUE
|
||||||
|
# rb_ary_flatten(ary)
|
||||||
|
# VALUE ary;
|
||||||
|
# {
|
||||||
|
# ary = rb_obj_dup(ary);
|
||||||
|
# rb_ary_flatten_bang(ary);
|
||||||
|
# return ary;
|
||||||
|
# }
|
||||||
|
#
|
||||||
|
# ...
|
||||||
|
#
|
||||||
|
# void
|
||||||
|
# Init_Array()
|
||||||
|
# {
|
||||||
|
# ...
|
||||||
|
# rb_define_method(rb_cArray, "flatten", rb_ary_flatten, 0);
|
||||||
|
#
|
||||||
|
# Here RDoc will determine from the rb_define_method line that there's a
|
||||||
|
# method called "flatten" in class Array, and will look for the implementation
|
||||||
|
# in the method rb_ary_flatten. It will then use the comment from that
|
||||||
|
# method in the HTML output. This method must be in the same source file
|
||||||
|
# as the rb_define_method.
|
||||||
|
#
|
||||||
|
# C classes can be diagramed (see /tc/dl/ruby/ruby/error.c), and RDoc
|
||||||
|
# integrates C and Ruby source into one tree
|
||||||
|
|
||||||
|
# Classes and modules built in to the interpreter. We need
|
||||||
|
# these to define superclasses of user objects
|
||||||
|
|
||||||
|
require "rdoc/code_objects"
|
||||||
|
require "rdoc/parsers/parserfactory"
|
||||||
|
|
||||||
|
|
||||||
|
module RDoc
|
||||||
|
|
||||||
|
KNOWN_CLASSES = {
|
||||||
|
"rb_cObject" => "Object",
|
||||||
|
"rb_cArray" => "Array",
|
||||||
|
"rb_cBignum" => "Bignum",
|
||||||
|
"rb_cClass" => "Class",
|
||||||
|
"rb_cDir" => "Dir",
|
||||||
|
"rb_cData" => "Data",
|
||||||
|
"rb_cFalseClass" => "FalseClass",
|
||||||
|
"rb_cFile" => "File",
|
||||||
|
"rb_cFixnum" => "Fixnum",
|
||||||
|
"rb_cFloat" => "Float",
|
||||||
|
"rb_cHash" => "Hash",
|
||||||
|
"rb_cInteger" => "Integer",
|
||||||
|
"rb_cIO" => "IO",
|
||||||
|
"rb_cModule" => "Module",
|
||||||
|
"rb_cNilClass" => "NilClass",
|
||||||
|
"rb_cNumeric" => "Numeric",
|
||||||
|
"rb_cProc" => "Proc",
|
||||||
|
"rb_cRange" => "Range",
|
||||||
|
"rb_cRegexp" => "Regexp",
|
||||||
|
"rb_cString" => "String",
|
||||||
|
"rb_cSymbol" => "Symbol",
|
||||||
|
"rb_cThread" => "Thread",
|
||||||
|
"rb_cTime" => "Time",
|
||||||
|
"rb_cTrueClass" => "TrueClass",
|
||||||
|
"rb_cStruct" => "Struct",
|
||||||
|
"rb_eException" => "Exception",
|
||||||
|
"rb_eStandardError" => "StandardError",
|
||||||
|
"rb_eSystemExit" => "SystemExit",
|
||||||
|
"rb_eInterrupt" => "Interrupt",
|
||||||
|
"rb_eSignal" => "Signal",
|
||||||
|
"rb_eFatal" => "Fatal",
|
||||||
|
"rb_eArgError" => "ArgError",
|
||||||
|
"rb_eEOFError" => "EOFError",
|
||||||
|
"rb_eIndexError" => "IndexError",
|
||||||
|
"rb_eRangeError" => "RangeError",
|
||||||
|
"rb_eIOError" => "IOError",
|
||||||
|
"rb_eRuntimeError" => "RuntimeError",
|
||||||
|
"rb_eSecurityError" => "SecurityError",
|
||||||
|
"rb_eSystemCallError" => "SystemCallError",
|
||||||
|
"rb_eTypeError" => "TypeError",
|
||||||
|
"rb_eZeroDivError" => "ZeroDivError",
|
||||||
|
"rb_eNotImpError" => "NotImpError",
|
||||||
|
"rb_eNoMemError" => "NoMemError",
|
||||||
|
"rb_eFloatDomainError" => "FloatDomainError",
|
||||||
|
"rb_eScriptError" => "ScriptError",
|
||||||
|
"rb_eNameError" => "NameError",
|
||||||
|
"rb_eSyntaxError" => "SyntaxError",
|
||||||
|
"rb_eLoadError" => "LoadError",
|
||||||
|
|
||||||
|
"rb_mKernel" => "Kernel",
|
||||||
|
"rb_mComparable" => "Comparable",
|
||||||
|
"rb_mEnumerable" => "Enumerable",
|
||||||
|
"rb_mPrecision" => "Precision",
|
||||||
|
"rb_mErrno" => "Errno",
|
||||||
|
"rb_mFileTest" => "FileTest",
|
||||||
|
"rb_mGC" => "GC",
|
||||||
|
"rb_mMath" => "Math",
|
||||||
|
"rb_mProcess" => "Process"
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
# See rdoc/c_parse.rb
|
||||||
|
|
||||||
|
class C_Parser
|
||||||
|
|
||||||
|
|
||||||
|
extend ParserFactory
|
||||||
|
parse_files_matching(/\.(c|cc|cpp|CC)$/)
|
||||||
|
|
||||||
|
|
||||||
|
# prepare to parse a C file
|
||||||
|
def initialize(top_level, file_name, body, options)
|
||||||
|
@known_classes = KNOWN_CLASSES.dup
|
||||||
|
@body = body
|
||||||
|
@options = options
|
||||||
|
@top_level = top_level
|
||||||
|
@classes = Hash.new
|
||||||
|
end
|
||||||
|
|
||||||
|
# Extract the classes/modules and methods from a C file
|
||||||
|
# and return the corresponding top-level object
|
||||||
|
def scan
|
||||||
|
remove_commented_out_lines
|
||||||
|
do_classes
|
||||||
|
do_methods
|
||||||
|
@top_level
|
||||||
|
end
|
||||||
|
|
||||||
|
#######
|
||||||
|
private
|
||||||
|
#######
|
||||||
|
|
||||||
|
# remove lines that are commented out that might otherwise get
|
||||||
|
# picked up when scanning for classes and methods
|
||||||
|
|
||||||
|
def remove_commented_out_lines
|
||||||
|
@body.gsub!(%r{//.*rb_define_}, '//')
|
||||||
|
end
|
||||||
|
|
||||||
|
def handle_class_module(var_name, class_mod, class_name, parent, in_module)
|
||||||
|
@known_classes[var_name] = class_name
|
||||||
|
parent_name = @known_classes[parent] || parent
|
||||||
|
|
||||||
|
if in_module
|
||||||
|
enclosure = @classes[in_module]
|
||||||
|
unless enclosure
|
||||||
|
$stderr.puts("Enclosing class/module '#{in_module}' for " +
|
||||||
|
class_mod + " #{class_name} not known")
|
||||||
|
return
|
||||||
|
end
|
||||||
|
else
|
||||||
|
enclosure = @top_level
|
||||||
|
end
|
||||||
|
|
||||||
|
if class_mod == "class"
|
||||||
|
cm = enclosure.add_class(NormalClass, class_name, parent_name)
|
||||||
|
else
|
||||||
|
cm = enclosure.add_module(NormalModule, class_name)
|
||||||
|
end
|
||||||
|
cm.record_location(enclosure.toplevel)
|
||||||
|
@classes[var_name] = cm
|
||||||
|
end
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
def do_classes
|
||||||
|
@body.scan(/(\w+)\s* = \s*rb_define_module\(\s*"(\w+)"\s*\)/mx) do
|
||||||
|
|var_name, class_name|
|
||||||
|
handle_class_module(var_name, "module", class_name, nil, nil)
|
||||||
|
end
|
||||||
|
|
||||||
|
@body.scan(/(\w+)\s* = \s*rb_define_module_under
|
||||||
|
\(
|
||||||
|
\s*(\w+),
|
||||||
|
\s*"(\w+)"
|
||||||
|
\)/mx) do
|
||||||
|
|
||||||
|
|var_name, in_module, class_name|
|
||||||
|
handle_class_module(var_name, "module", class_name, nil, in_module)
|
||||||
|
end
|
||||||
|
|
||||||
|
@body.scan(/(\w+)\s* = \s*rb_define_class
|
||||||
|
\(
|
||||||
|
\s*"(\w+)",
|
||||||
|
\s*(\w+)\s*
|
||||||
|
\)/mx) do
|
||||||
|
|
||||||
|
|var_name, class_name, parent|
|
||||||
|
handle_class_module(var_name, "class", class_name, parent, nil)
|
||||||
|
end
|
||||||
|
|
||||||
|
@body.scan(/(\w+)\s* = \s*rb_define_class_under
|
||||||
|
\(
|
||||||
|
\s*(\w+),
|
||||||
|
\s*"(\w+)",
|
||||||
|
\s*(\w+)\s*
|
||||||
|
\)/mx) do
|
||||||
|
|
||||||
|
|var_name, in_module, class_name, parent|
|
||||||
|
handle_class_module(var_name, "class", class_name, parent, in_module)
|
||||||
|
end
|
||||||
|
|
||||||
|
end
|
||||||
|
|
||||||
|
|
||||||
|
def do_methods
|
||||||
|
@body.scan(/rb_define_(singleton_method|method|module_function)\(\s*(\w+),
|
||||||
|
\s*"([^"]+)",
|
||||||
|
\s*(?:RUBY_METHOD_FUNC\(|VALUEFUNC\()?(\w+)\)?,
|
||||||
|
\s*(-?\w+)\s*\)/xm) do
|
||||||
|
|type, var_name, meth_name, meth_body, param_count|
|
||||||
|
|
||||||
|
class_name = @known_classes[var_name] || var_name
|
||||||
|
class_obj = @classes[var_name]
|
||||||
|
if class_obj
|
||||||
|
meth_obj = AnyMethod.new("", meth_name)
|
||||||
|
meth_obj.singleton = type == "singleton_method"
|
||||||
|
|
||||||
|
p_count = (Integer(param_count) rescue -1)
|
||||||
|
|
||||||
|
if p_count < 0
|
||||||
|
meth_obj.params = "(...)"
|
||||||
|
elsif p_count == 0
|
||||||
|
meth_obj.params = "()"
|
||||||
|
else
|
||||||
|
meth_obj.params = "(" +
|
||||||
|
(1..p_count).map{|i| "p#{i}"}.join(", ") +
|
||||||
|
")"
|
||||||
|
end
|
||||||
|
|
||||||
|
find_body(meth_body, meth_obj)
|
||||||
|
class_obj.add_method(meth_obj)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
# Find the C code corresponding to a c method
|
||||||
|
def find_body(meth_name, meth_obj)
|
||||||
|
if @body =~ %r{((?>/\*.*?\*/\s+))(static\s+)?VALUE\s+#{meth_name}
|
||||||
|
\s*(\(.*?\)).*?^}xm
|
||||||
|
comment, params = $1, $3
|
||||||
|
body_text = $&
|
||||||
|
|
||||||
|
# see if we can find the whole body
|
||||||
|
|
||||||
|
re = Regexp.escape(body_text) + "[^(]*^{.*?^}"
|
||||||
|
if Regexp.new(re, Regexp::MULTILINE).match(@body)
|
||||||
|
body_text = $&
|
||||||
|
end
|
||||||
|
|
||||||
|
meth_obj.params = params
|
||||||
|
meth_obj.start_collecting_tokens
|
||||||
|
meth_obj.add_token(RubyToken::Token.new(1,1).set_text(body_text))
|
||||||
|
meth_obj.comment = mangle_comment(comment)
|
||||||
|
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
# Remove the /*'s and leading asterisks from C comments
|
||||||
|
|
||||||
|
def mangle_comment(comment)
|
||||||
|
comment.sub!(%r{/\*+}) { " " * $&.length }
|
||||||
|
comment.sub!(%r{\*+/}) { " " * $&.length }
|
||||||
|
comment.gsub!(/^[ \t]*\*/m) { " " * $&.length }
|
||||||
|
comment
|
||||||
|
end
|
||||||
|
|
||||||
|
end
|
||||||
|
|
||||||
|
end
|
||||||
118
lib/rdoc/parsers/parse_f95.rb
Normal file
118
lib/rdoc/parsers/parse_f95.rb
Normal file
|
|
@ -0,0 +1,118 @@
|
||||||
|
# Parse a Fortran 95 file.
|
||||||
|
|
||||||
|
require "rdoc/code_objects"
|
||||||
|
|
||||||
|
module RDoc
|
||||||
|
|
||||||
|
# See rdoc/parsers/parse_f95.rb
|
||||||
|
|
||||||
|
class Token
|
||||||
|
|
||||||
|
NO_TEXT = "??".freeze
|
||||||
|
|
||||||
|
def initialize(line_no, char_no)
|
||||||
|
@line_no = line_no
|
||||||
|
@char_no = char_no
|
||||||
|
@text = NO_TEXT
|
||||||
|
end
|
||||||
|
# Because we're used in contexts that expect to return a token,
|
||||||
|
# we set the text string and then return ourselves
|
||||||
|
def set_text(text)
|
||||||
|
@text = text
|
||||||
|
self
|
||||||
|
end
|
||||||
|
|
||||||
|
attr_reader :line_no, :char_no, :text
|
||||||
|
|
||||||
|
end
|
||||||
|
|
||||||
|
class Fortran95parser
|
||||||
|
|
||||||
|
extend ParserFactory
|
||||||
|
parse_files_matching(/\.(f9(0|5)|F)$/)
|
||||||
|
|
||||||
|
# prepare to parse a Fortran 95 file
|
||||||
|
def initialize(top_level, file_name, body, options)
|
||||||
|
@body = body
|
||||||
|
@options = options
|
||||||
|
@top_level = top_level
|
||||||
|
@progress = $stderr unless options.quiet
|
||||||
|
end
|
||||||
|
|
||||||
|
# devine code constructs
|
||||||
|
def scan
|
||||||
|
|
||||||
|
# modules and programs
|
||||||
|
if @body =~ /^(module|program)\s+(\w+)/i
|
||||||
|
progress "m"
|
||||||
|
f9x_module = @top_level.add_module NormalClass, $2
|
||||||
|
f9x_module.record_location @top_level
|
||||||
|
first_comment, second_comment = $`.gsub(/^!\s?/,"").split "\n\s*\n"
|
||||||
|
if second_comment
|
||||||
|
@top_level.comment = first_comment if first_comment
|
||||||
|
f9x_module.comment = second_comment
|
||||||
|
else
|
||||||
|
f9x_module.comment = first_comment if first_comment
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
# use modules
|
||||||
|
remaining_code = @body
|
||||||
|
while remaining_code =~ /^\s*use\s+(\w+)/i
|
||||||
|
remaining_code = $~.post_match
|
||||||
|
progress "."
|
||||||
|
f9x_module.add_include Include.new($1, "") if f9x_module
|
||||||
|
end
|
||||||
|
|
||||||
|
# subroutines
|
||||||
|
remaining_code = @body
|
||||||
|
while remaining_code =~ /^\s*subroutine\s+(\w+)\s*\((.*?)\)/im
|
||||||
|
remaining_code = $~.post_match
|
||||||
|
subroutine = AnyMethod.new("Text", $1)
|
||||||
|
subroutine.singleton = false
|
||||||
|
|
||||||
|
prematchText = $~.pre_match
|
||||||
|
params = $2
|
||||||
|
params.gsub!(/&/,'')
|
||||||
|
subroutine.params = params
|
||||||
|
comment = find_comments prematchText
|
||||||
|
subroutine.comment = comment if comment
|
||||||
|
|
||||||
|
subroutine.start_collecting_tokens
|
||||||
|
remaining_code =~ /^\s*end\s+subroutine/i
|
||||||
|
code = "subroutine #{subroutine.name} (#{subroutine.params})\n"
|
||||||
|
code += $~.pre_match
|
||||||
|
code += "\nend subroutine\n"
|
||||||
|
subroutine.add_token Token.new(1,1).set_text(code)
|
||||||
|
|
||||||
|
progress "s"
|
||||||
|
f9x_module.add_method subroutine if f9x_module
|
||||||
|
end
|
||||||
|
|
||||||
|
@top_level
|
||||||
|
|
||||||
|
end
|
||||||
|
|
||||||
|
def find_comments text
|
||||||
|
lines = text.split("\n").reverse
|
||||||
|
comment_block = Array.new
|
||||||
|
lines.each do |line|
|
||||||
|
break if line =~ /^\s*\w/
|
||||||
|
comment_block.unshift line.sub(/^!\s?/,"")
|
||||||
|
end
|
||||||
|
nice_lines = comment_block.join("\n").split "\n\s*\n"
|
||||||
|
nice_lines.shift
|
||||||
|
nice_lines.shift
|
||||||
|
nice_lines.shift
|
||||||
|
end
|
||||||
|
|
||||||
|
def progress(char)
|
||||||
|
unless @options.quiet
|
||||||
|
@progress.print(char)
|
||||||
|
@progress.flush
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
end # class Fortran95parser
|
||||||
|
|
||||||
|
end # module RDoc
|
||||||
2494
lib/rdoc/parsers/parse_rb.rb
Normal file
2494
lib/rdoc/parsers/parse_rb.rb
Normal file
File diff suppressed because it is too large
Load diff
37
lib/rdoc/parsers/parse_simple.rb
Normal file
37
lib/rdoc/parsers/parse_simple.rb
Normal file
|
|
@ -0,0 +1,37 @@
|
||||||
|
# Parse a non-source file. We basically take the whole thing
|
||||||
|
# as one big comment. If the first character in the file
|
||||||
|
# is '#', we strip leading pound signs.
|
||||||
|
|
||||||
|
|
||||||
|
require "rdoc/code_objects"
|
||||||
|
require "rdoc/markup/simple_markup/preprocess"
|
||||||
|
|
||||||
|
module RDoc
|
||||||
|
# See rdoc/parsers/parse_c.rb
|
||||||
|
|
||||||
|
class SimpleParser
|
||||||
|
|
||||||
|
# prepare to parse a plain file
|
||||||
|
def initialize(top_level, file_name, body, options)
|
||||||
|
|
||||||
|
preprocess = SM::PreProcess.new(file_name, options.rdoc_include)
|
||||||
|
|
||||||
|
preprocess.handle(body) do |directive, param|
|
||||||
|
$stderr.puts "Unrecognized directive '#{directive}' in #{file_name}"
|
||||||
|
end
|
||||||
|
|
||||||
|
@body = body
|
||||||
|
@options = options
|
||||||
|
@top_level = top_level
|
||||||
|
end
|
||||||
|
|
||||||
|
# Extract the file contents and attach them to the toplevel as a
|
||||||
|
# comment
|
||||||
|
|
||||||
|
def scan
|
||||||
|
# @body.gsub(/^(\s\n)+/, '')
|
||||||
|
@top_level.comment = @body
|
||||||
|
@top_level
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
86
lib/rdoc/parsers/parserfactory.rb
Normal file
86
lib/rdoc/parsers/parserfactory.rb
Normal file
|
|
@ -0,0 +1,86 @@
|
||||||
|
require "rdoc/parsers/parse_simple"
|
||||||
|
|
||||||
|
module RDoc
|
||||||
|
|
||||||
|
# A parser is simple a class that implements
|
||||||
|
#
|
||||||
|
# #initialize(file_name, body, options)
|
||||||
|
#
|
||||||
|
# and
|
||||||
|
#
|
||||||
|
# #scan
|
||||||
|
#
|
||||||
|
# The initialize method takes a file name to be used, the body of the
|
||||||
|
# file, and an RDoc::Options object. The scan method is then called
|
||||||
|
# to return an appropriately parsed TopLevel code object.
|
||||||
|
|
||||||
|
# The ParseFactory is used to redirect to the correct parser given a filename
|
||||||
|
# extension. This magic works because individual parsers have to register
|
||||||
|
# themselves with us as they are loaded in. The do this using the following
|
||||||
|
# incantation
|
||||||
|
#
|
||||||
|
#
|
||||||
|
# require "rdoc/parsers/parsefactory"
|
||||||
|
#
|
||||||
|
# module RDoc
|
||||||
|
#
|
||||||
|
# class XyzParser
|
||||||
|
# extend ParseFactory <<<<
|
||||||
|
# parse_files_matching /\.xyz$/ <<<<
|
||||||
|
#
|
||||||
|
# def initialize(file_name, body, options)
|
||||||
|
# ...
|
||||||
|
# end
|
||||||
|
#
|
||||||
|
# def scan
|
||||||
|
# ...
|
||||||
|
# end
|
||||||
|
# end
|
||||||
|
# end
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
module ParserFactory
|
||||||
|
|
||||||
|
@@parsers = []
|
||||||
|
|
||||||
|
Parsers = Struct.new(:regexp, :parser)
|
||||||
|
|
||||||
|
# Record the fact that a particular class parses files that
|
||||||
|
# match a given extension
|
||||||
|
|
||||||
|
def parse_files_matching(regexp)
|
||||||
|
@@parsers.unshift Parsers.new(regexp, self)
|
||||||
|
end
|
||||||
|
|
||||||
|
# Return a parser that can handle a particular extension
|
||||||
|
|
||||||
|
def ParserFactory.can_parse(file_name)
|
||||||
|
@@parsers.find {|p| p.regexp.match(file_name) }
|
||||||
|
end
|
||||||
|
|
||||||
|
# Alias an extension to another extension. After this call,
|
||||||
|
# files ending "new_ext" will be parsed using the same parser
|
||||||
|
# as "old_ext"
|
||||||
|
|
||||||
|
def ParserFactory.alias_extension(old_ext, new_ext)
|
||||||
|
parser = ParserFactory.can_parse("xxx.#{old_ext}")
|
||||||
|
return false unless parser
|
||||||
|
@@parsers.unshift Parsers.new(Regexp.new("\\.#{new_ext}$"), parser.parser)
|
||||||
|
true
|
||||||
|
end
|
||||||
|
|
||||||
|
# Find the correct parser for a particular file name. Return a
|
||||||
|
# SimpleParser for ones that we don't know
|
||||||
|
|
||||||
|
def ParserFactory.parser_for(top_level, file_name, body, options)
|
||||||
|
parser_description = can_parse(file_name)
|
||||||
|
if parser_description
|
||||||
|
parser = parser_description.parser
|
||||||
|
else
|
||||||
|
parser = SimpleParser
|
||||||
|
end
|
||||||
|
parser.new(top_level, file_name, body, options)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
219
lib/rdoc/rdoc.rb
Normal file
219
lib/rdoc/rdoc.rb
Normal file
|
|
@ -0,0 +1,219 @@
|
||||||
|
# See README.
|
||||||
|
#
|
||||||
|
|
||||||
|
|
||||||
|
RDOC_VERSION = "1.0pr1"
|
||||||
|
|
||||||
|
rcs = '$Date$ $Revision$'.
|
||||||
|
gsub(/\$/, '').
|
||||||
|
sub(/Date: /, ': ').
|
||||||
|
sub(/ Revision: (\S+)/) { "(#$1)" }
|
||||||
|
|
||||||
|
VERSION_STRING = %{RDoc V} + RDOC_VERSION + rcs
|
||||||
|
|
||||||
|
|
||||||
|
require 'rdoc/parsers/parse_rb.rb'
|
||||||
|
require 'rdoc/parsers/parse_c.rb'
|
||||||
|
require 'rdoc/parsers/parse_f95.rb'
|
||||||
|
|
||||||
|
require 'rdoc/parsers/parse_simple.rb'
|
||||||
|
require 'rdoc/options'
|
||||||
|
|
||||||
|
require 'rdoc/diagram'
|
||||||
|
|
||||||
|
require 'find'
|
||||||
|
require 'ftools'
|
||||||
|
|
||||||
|
# We put rdoc stuff in the RDoc module to avoid namespace
|
||||||
|
# clutter.
|
||||||
|
#
|
||||||
|
# ToDo: This isn't universally true.
|
||||||
|
|
||||||
|
module RDoc
|
||||||
|
|
||||||
|
# Exception thrown by any rdoc error. Only the #message part is
|
||||||
|
# of use externally.
|
||||||
|
|
||||||
|
class RDocError < Exception
|
||||||
|
end
|
||||||
|
|
||||||
|
# Encapsulate the production of rdoc documentation. Basically
|
||||||
|
# you can use this as you would invoke rdoc from the command
|
||||||
|
# line:
|
||||||
|
#
|
||||||
|
# rdoc = RDoc::RDoc.new
|
||||||
|
# rdoc.document(args)
|
||||||
|
#
|
||||||
|
# where _args_ is an array of strings, each corresponding to
|
||||||
|
# an argument you'd give rdoc on the command line. See rdoc/rdoc.rb
|
||||||
|
# for details.
|
||||||
|
|
||||||
|
class RDoc
|
||||||
|
|
||||||
|
##
|
||||||
|
# This is the list of output generators that we
|
||||||
|
# support
|
||||||
|
|
||||||
|
Generator = Struct.new(:file_name, :class_name, :key)
|
||||||
|
|
||||||
|
GENERATORS = {}
|
||||||
|
$:.collect {|d|
|
||||||
|
File::expand_path(d)
|
||||||
|
}.find_all {|d|
|
||||||
|
File::directory?("#{d}/rdoc/generators")
|
||||||
|
}.each {|dir|
|
||||||
|
Dir::entries("#{dir}/rdoc/generators").each {|gen|
|
||||||
|
next unless /(\w+)_generator.rb$/ =~ gen
|
||||||
|
type = $1
|
||||||
|
unless GENERATORS.has_key? type
|
||||||
|
GENERATORS[type] = Generator.new("rdoc/generators/#{gen}",
|
||||||
|
"#{type.upcase}Generator".intern,
|
||||||
|
type)
|
||||||
|
end
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#######
|
||||||
|
private
|
||||||
|
#######
|
||||||
|
|
||||||
|
##
|
||||||
|
# Report an error message and exit
|
||||||
|
|
||||||
|
def error(msg)
|
||||||
|
raise RDocError.new(msg)
|
||||||
|
end
|
||||||
|
|
||||||
|
##
|
||||||
|
# Create an output dir if it doesn't exist. If it does
|
||||||
|
# exist, but doesn't contain the flag file <tt>created.rid</tt>
|
||||||
|
# then we refuse to use it, as we may clobber some
|
||||||
|
# manually generated documentation
|
||||||
|
|
||||||
|
def setup_output_dir(op_dir)
|
||||||
|
flag_file = File.join(op_dir, "created.rid")
|
||||||
|
if File.exist?(op_dir)
|
||||||
|
unless File.directory?(op_dir)
|
||||||
|
error "'#{op_dir}' exists, and is not a directory"
|
||||||
|
end
|
||||||
|
unless File.file?(flag_file)
|
||||||
|
error "\nDirectory #{op_dir} already exists, but it looks like it\n" +
|
||||||
|
"isn't an RDoc directory. Because RDoc doesn't want to risk\n" +
|
||||||
|
"destroying any of your existing files, you'll need to\n" +
|
||||||
|
"specify a different output directory name (using the\n" +
|
||||||
|
"--op <dir> option).\n\n"
|
||||||
|
end
|
||||||
|
else
|
||||||
|
File.makedirs(op_dir)
|
||||||
|
end
|
||||||
|
File.open(flag_file, "w") {|f| f.puts Time.now }
|
||||||
|
end
|
||||||
|
|
||||||
|
|
||||||
|
# Given a list of files and directories, create a list
|
||||||
|
# of all the Ruby files they contain.
|
||||||
|
|
||||||
|
def normalized_file_list(options, *relative_files)
|
||||||
|
file_list = []
|
||||||
|
|
||||||
|
relative_files.each do |rel_file_name|
|
||||||
|
|
||||||
|
case type = File.stat(rel_file_name).ftype
|
||||||
|
when "file"
|
||||||
|
file_list << rel_file_name
|
||||||
|
when "directory"
|
||||||
|
next if options.exclude && options.exclude =~ rel_file_name
|
||||||
|
Find.find(rel_file_name) do |fn|
|
||||||
|
next if options.exclude && options.exclude =~ fn
|
||||||
|
next unless ParserFactory.can_parse(fn)
|
||||||
|
next unless File.file?(fn)
|
||||||
|
|
||||||
|
file_list << fn.sub(%r{\./}, '')
|
||||||
|
end
|
||||||
|
else
|
||||||
|
raise RDocError.new("I can't deal with a #{type} #{rel_file_name}")
|
||||||
|
end
|
||||||
|
end
|
||||||
|
file_list
|
||||||
|
end
|
||||||
|
|
||||||
|
# Parse each file on the command line, recursively entering
|
||||||
|
# directories
|
||||||
|
|
||||||
|
def parse_files(options)
|
||||||
|
|
||||||
|
file_info = []
|
||||||
|
|
||||||
|
files = options.files
|
||||||
|
files = ["."] if files.empty?
|
||||||
|
|
||||||
|
file_list = normalized_file_list(options, *files)
|
||||||
|
|
||||||
|
file_list.each do |fn|
|
||||||
|
$stderr.printf("\n%35s: ", File.basename(fn)) unless options.quiet
|
||||||
|
|
||||||
|
content = File.open(fn, "r") {|f| f.read}
|
||||||
|
|
||||||
|
top_level = TopLevel.new(fn)
|
||||||
|
parser = ParserFactory.parser_for(top_level, fn, content, options)
|
||||||
|
file_info << parser.scan
|
||||||
|
end
|
||||||
|
|
||||||
|
file_info
|
||||||
|
end
|
||||||
|
|
||||||
|
|
||||||
|
public
|
||||||
|
|
||||||
|
###################################################################
|
||||||
|
#
|
||||||
|
# Format up one or more files according to the given arguments.
|
||||||
|
# For simplicity, _argv_ is an array of strings, equivalent to the
|
||||||
|
# strings that would be passed on the command line. (This isn't a
|
||||||
|
# coincidence, as we _do_ pass in ARGV when running
|
||||||
|
# interactively). For a list of options, see rdoc/rdoc.rb. By
|
||||||
|
# default, output will be stored in a directory called +doc+ below
|
||||||
|
# the current directory, so make sure you're somewhere writable
|
||||||
|
# before invoking.
|
||||||
|
#
|
||||||
|
# Throws: RDocError on error
|
||||||
|
|
||||||
|
def document(argv)
|
||||||
|
|
||||||
|
TopLevel::reset
|
||||||
|
|
||||||
|
options = Options.instance
|
||||||
|
options.parse(argv, GENERATORS)
|
||||||
|
|
||||||
|
file_info = parse_files(options)
|
||||||
|
|
||||||
|
gen = options.generator
|
||||||
|
|
||||||
|
$stderr.puts "\nGenerating #{gen.key.upcase}..." unless options.quiet
|
||||||
|
|
||||||
|
require gen.file_name
|
||||||
|
|
||||||
|
gen_class = Generators.const_get(gen.class_name)
|
||||||
|
|
||||||
|
unless file_info.empty?
|
||||||
|
gen = gen_class.for(options)
|
||||||
|
|
||||||
|
pwd = Dir.pwd
|
||||||
|
|
||||||
|
unless options.all_one_file
|
||||||
|
setup_output_dir(options.op_dir)
|
||||||
|
Dir.chdir(options.op_dir)
|
||||||
|
end
|
||||||
|
|
||||||
|
begin
|
||||||
|
Diagram.new(file_info, options).draw if options.diagram
|
||||||
|
gen.generate(file_info)
|
||||||
|
ensure
|
||||||
|
Dir.chdir(pwd)
|
||||||
|
end
|
||||||
|
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
234
lib/rdoc/template.rb
Normal file
234
lib/rdoc/template.rb
Normal file
|
|
@ -0,0 +1,234 @@
|
||||||
|
# Cheap-n-cheerful HTML page template system. You create a
|
||||||
|
# template containing:
|
||||||
|
#
|
||||||
|
# * variable names between percent signs (<tt>%fred%</tt>)
|
||||||
|
# * blocks of repeating stuff:
|
||||||
|
#
|
||||||
|
# START:key
|
||||||
|
# ... stuff
|
||||||
|
# END:key
|
||||||
|
#
|
||||||
|
# You feed the code a hash. For simple variables, the values
|
||||||
|
# are resolved directly from the hash. For blocks, the hash entry
|
||||||
|
# corresponding to +key+ will be an array of hashes. The block will
|
||||||
|
# be generated once for each entry. Blocks can be nested arbitrarily
|
||||||
|
# deeply.
|
||||||
|
#
|
||||||
|
# The template may also contain
|
||||||
|
#
|
||||||
|
# IF:key
|
||||||
|
# ... stuff
|
||||||
|
# ENDIF:key
|
||||||
|
#
|
||||||
|
# _stuff_ will only be included in the output if the corresponding
|
||||||
|
# key is set in the value hash.
|
||||||
|
#
|
||||||
|
# Usage: Given a set of templates <tt>T1, T2,</tt> etc
|
||||||
|
#
|
||||||
|
# values = { "name" => "Dave", state => "TX" }
|
||||||
|
#
|
||||||
|
# t = TemplatePage.new(T1, T2, T3)
|
||||||
|
# File.open(name, "w") {|f| t.write_html_on(f, values)}
|
||||||
|
# or
|
||||||
|
# res = ''
|
||||||
|
# t.write_html_on(res, values)
|
||||||
|
#
|
||||||
|
#
|
||||||
|
|
||||||
|
class TemplatePage
|
||||||
|
|
||||||
|
##########
|
||||||
|
# A context holds a stack of key/value pairs (like a symbol
|
||||||
|
# table). When asked to resolve a key, it first searches the top of
|
||||||
|
# the stack, then the next level, and so on until it finds a match
|
||||||
|
# (or runs out of entries)
|
||||||
|
|
||||||
|
class Context
|
||||||
|
def initialize
|
||||||
|
@stack = []
|
||||||
|
end
|
||||||
|
|
||||||
|
def push(hash)
|
||||||
|
@stack.push(hash)
|
||||||
|
end
|
||||||
|
|
||||||
|
def pop
|
||||||
|
@stack.pop
|
||||||
|
end
|
||||||
|
|
||||||
|
# Find a scalar value, throwing an exception if not found. This
|
||||||
|
# method is used when substituting the %xxx% constructs
|
||||||
|
|
||||||
|
def find_scalar(key)
|
||||||
|
@stack.reverse_each do |level|
|
||||||
|
if val = level[key]
|
||||||
|
return val unless val.kind_of? Array
|
||||||
|
end
|
||||||
|
end
|
||||||
|
raise "Template error: can't find variable '#{key}'"
|
||||||
|
end
|
||||||
|
|
||||||
|
# Lookup any key in the stack of hashes
|
||||||
|
|
||||||
|
def lookup(key)
|
||||||
|
@stack.reverse_each do |level|
|
||||||
|
val = level[key]
|
||||||
|
return val if val
|
||||||
|
end
|
||||||
|
nil
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
#########
|
||||||
|
# Simple class to read lines out of a string
|
||||||
|
|
||||||
|
class LineReader
|
||||||
|
# we're initialized with an array of lines
|
||||||
|
def initialize(lines)
|
||||||
|
@lines = lines
|
||||||
|
end
|
||||||
|
|
||||||
|
# read the next line
|
||||||
|
def read
|
||||||
|
@lines.shift
|
||||||
|
end
|
||||||
|
|
||||||
|
# Return a list of lines up to the line that matches
|
||||||
|
# a pattern. That last line is discarded.
|
||||||
|
def read_up_to(pattern)
|
||||||
|
res = []
|
||||||
|
while line = read
|
||||||
|
if pattern.match(line)
|
||||||
|
return LineReader.new(res)
|
||||||
|
else
|
||||||
|
res << line
|
||||||
|
end
|
||||||
|
end
|
||||||
|
raise "Missing end tag in template: #{pattern.source}"
|
||||||
|
end
|
||||||
|
|
||||||
|
# Return a copy of ourselves that can be modified without
|
||||||
|
# affecting us
|
||||||
|
def dup
|
||||||
|
LineReader.new(@lines.dup)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
# +templates+ is an array of strings containing the templates.
|
||||||
|
# We start at the first, and substitute in subsequent ones
|
||||||
|
# where the string <tt>!INCLUDE!</tt> occurs. For example,
|
||||||
|
# we could have the overall page template containing
|
||||||
|
#
|
||||||
|
# <html><body>
|
||||||
|
# <h1>Master</h1>
|
||||||
|
# !INCLUDE!
|
||||||
|
# </bost></html>
|
||||||
|
#
|
||||||
|
# and substitute subpages in to it by passing [master, sub_page].
|
||||||
|
# This gives us a cheap way of framing pages
|
||||||
|
|
||||||
|
def initialize(*templates)
|
||||||
|
result = "!INCLUDE!"
|
||||||
|
templates.each do |content|
|
||||||
|
result.sub!(/!INCLUDE!/, content)
|
||||||
|
end
|
||||||
|
@lines = LineReader.new(result.split($/))
|
||||||
|
end
|
||||||
|
|
||||||
|
# Render the templates into HTML, storing the result on +op+
|
||||||
|
# using the method <tt><<</tt>. The <tt>value_hash</tt> contains
|
||||||
|
# key/value pairs used to drive the substitution (as described above)
|
||||||
|
|
||||||
|
def write_html_on(op, value_hash)
|
||||||
|
@context = Context.new
|
||||||
|
op << substitute_into(@lines, value_hash).tr("\000", '\\')
|
||||||
|
end
|
||||||
|
|
||||||
|
|
||||||
|
# Substitute a set of key/value pairs into the given template.
|
||||||
|
# Keys with scalar values have them substituted directly into
|
||||||
|
# the page. Those with array values invoke <tt>substitute_array</tt>
|
||||||
|
# (below), which examples a block of the template once for each
|
||||||
|
# row in the array.
|
||||||
|
#
|
||||||
|
# This routine also copes with the <tt>IF:</tt>_key_ directive,
|
||||||
|
# removing chunks of the template if the corresponding key
|
||||||
|
# does not appear in the hash, and the START: directive, which
|
||||||
|
# loops its contents for each value in an array
|
||||||
|
|
||||||
|
def substitute_into(lines, values)
|
||||||
|
@context.push(values)
|
||||||
|
skip_to = nil
|
||||||
|
result = []
|
||||||
|
|
||||||
|
while line = lines.read
|
||||||
|
|
||||||
|
case line
|
||||||
|
|
||||||
|
when /^IF:(\w+)/
|
||||||
|
lines.read_up_to(/^ENDIF:#$1/) unless @context.lookup($1)
|
||||||
|
|
||||||
|
when /^IFNOT:(\w+)/
|
||||||
|
lines.read_up_to(/^ENDIF:#$1/) if @context.lookup($1)
|
||||||
|
|
||||||
|
when /^ENDIF:/
|
||||||
|
;
|
||||||
|
|
||||||
|
when /^START:(\w+)/
|
||||||
|
tag = $1
|
||||||
|
body = lines.read_up_to(/^END:#{tag}/)
|
||||||
|
inner_values = @context.lookup(tag)
|
||||||
|
raise "unknown tag: #{tag}" unless inner_values
|
||||||
|
raise "not array: #{tag}" unless inner_values.kind_of?(Array)
|
||||||
|
inner_values.each do |vals|
|
||||||
|
result << substitute_into(body.dup, vals)
|
||||||
|
end
|
||||||
|
else
|
||||||
|
result << expand_line(line.dup)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
@context.pop
|
||||||
|
|
||||||
|
result.join("\n")
|
||||||
|
end
|
||||||
|
|
||||||
|
# Given an individual line, we look for %xxx% constructs and
|
||||||
|
# HREF:ref:name: constructs, substituting for each.
|
||||||
|
|
||||||
|
def expand_line(line)
|
||||||
|
# Generate a cross reference if a reference is given,
|
||||||
|
# otherwise just fill in the name part
|
||||||
|
|
||||||
|
line.gsub!(/HREF:(\w+?):(\w+?):/) {
|
||||||
|
ref = @context.lookup($1)
|
||||||
|
name = @context.find_scalar($2)
|
||||||
|
|
||||||
|
if ref and !ref.kind_of?(Array)
|
||||||
|
"<a href=\"#{ref}\">#{name}</a>"
|
||||||
|
else
|
||||||
|
name
|
||||||
|
end
|
||||||
|
}
|
||||||
|
|
||||||
|
# Substitute in values for %xxx% constructs. This is made complex
|
||||||
|
# because the replacement string may contain characters that are
|
||||||
|
# meaningful to the regexp (like \1)
|
||||||
|
|
||||||
|
line = line.gsub(/%([a-zA-Z]\w*)%/) {
|
||||||
|
val = @context.find_scalar($1)
|
||||||
|
val.tr('\\', "\000")
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
line
|
||||||
|
rescue Exception => e
|
||||||
|
$stderr.puts "Error in template: #{e}"
|
||||||
|
$stderr.puts "Original line: #{line}"
|
||||||
|
exit
|
||||||
|
end
|
||||||
|
|
||||||
|
end
|
||||||
|
|
||||||
25
lib/rdoc/tokenstream.rb
Normal file
25
lib/rdoc/tokenstream.rb
Normal file
|
|
@ -0,0 +1,25 @@
|
||||||
|
# A TokenStream is a list of tokens, gathered during the parse
|
||||||
|
# of some entity (say a method). Entities populate these streams
|
||||||
|
# by being registered with the lexer. Any class can collect tokens
|
||||||
|
# by including TokenStream. From the outside, you use such an object
|
||||||
|
# by calling the start_collecting_tokens method, followed by calls
|
||||||
|
# to add_token and pop_token
|
||||||
|
|
||||||
|
module TokenStream
|
||||||
|
def token_stream
|
||||||
|
@token_stream
|
||||||
|
end
|
||||||
|
|
||||||
|
def start_collecting_tokens
|
||||||
|
@token_stream = []
|
||||||
|
end
|
||||||
|
def add_token(tk)
|
||||||
|
@token_stream << tk
|
||||||
|
end
|
||||||
|
def add_tokens(tks)
|
||||||
|
tks.each {|tk| add_token(tk)}
|
||||||
|
end
|
||||||
|
def pop_token
|
||||||
|
@token_stream.pop
|
||||||
|
end
|
||||||
|
end
|
||||||
Loading…
Add table
Add a link
Reference in a new issue