kotovalexarian-likes-github/ruby--ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
Code Releases Activity

* lib/rdoc/markup: Remove ListBase and Line constants.

Browse source 
* lib/rdoc/ri: Allow output IO to be specified.

* test/rdoc/parser/test_parse_c.rb: Move up one level, fixed.

* test/rdoc/parser/test_rdoc_markup_attribute_manager.rb: Renamed to
  match new class name, updated to match new classes.

* test/rdoc/test_rdoc_ri_formatter.rb: Start of RI formatting tests.

* test/rdoc/test_rdoc_ri_attribute_manager.rb: Start of
  RDoc::RI::AttributeManager tests.

* test/rdoc/test_simple_markup.rb: Moved to match new class name.



git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@15120 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
drbrain 2008-01-19 00:06:19 +00:00
parent 9872d4d600
commit 8d37cefaf8
15 changed files with 443 additions and 261 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
ChangeLog
View file

@ -1,3 +1,21 @@
Sat Jan 19 08:58:47 2008 Eric Hodel <drbrain@segment7.net>
* lib/rdoc/markup: Remove ListBase and Line constants.
* lib/rdoc/ri: Allow output IO to be specified.
* test/rdoc/parser/test_parse_c.rb: Move up one level, fixed.
* test/rdoc/parser/test_rdoc_markup_attribute_manager.rb: Renamed to
match new class name, updated to match new classes.
* test/rdoc/test_rdoc_ri_formatter.rb: Start of RI formatting tests.
* test/rdoc/test_rdoc_ri_attribute_manager.rb: Start of
RDoc::RI::AttributeManager tests.
* test/rdoc/test_simple_markup.rb: Moved to match new class name.
Sat Jan 19 08:35:36 2008 Nobuyoshi Nakada <nobu@ruby-lang.org>
* parse.y (parser_prepare): get encoding from the first line.

33
lib/rdoc/markup.rb
View file

@ -159,7 +159,6 @@ require 'rdoc'
#
#--
# Author:: Dave Thomas, dave@pragmaticprogrammer.com
# Version:: 0.0
# License:: Ruby license
class RDoc::Markup
@ -256,7 +255,7 @@ class RDoc::Markup
while line = @lines.next
if line.isBlank?
line.stamp(Line::BLANK, level)
line.stamp :BLANK, level
next
end
@ -282,7 +281,7 @@ class RDoc::Markup
#
if /^(---+)\s*$/ =~ active_line
line.stamp(Line::RULE, level, $1.length-2)
line.stamp :RULE, level, $1.length-2
next
end
@ -296,14 +295,14 @@ class RDoc::Markup
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
when "*","-" then :BULLET
when /^\d/ then :NUMBER
when /^[A-Z]/ then :UPPERALPHA
when /^[a-z]/ then :LOWERALPHA
else raise "Invalid List Type: #{self.inspect}"
end
line.stamp(Line::LIST, level+1, prefix, flag)
line.stamp :LIST, level+1, prefix, flag
text[margin, prefix_length] = " " * prefix_length
assign_types_to_lines(offset, level + 1)
next
@ -328,7 +327,7 @@ class RDoc::Markup
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.stamp :HEADING, 0, prefix_length
line.strip_leading(margin + prefix_length)
next
end
@ -338,9 +337,9 @@ class RDoc::Markup
if active_line[0] == SPACE
line.strip_leading(margin) if margin > 0
line.stamp(Line::VERBATIM, level)
line.stamp :VERBATIM, level
else
line.stamp(Line::PARAGRAPH, level)
line.stamp :PARAGRAPH, level
end
end
end
@ -369,10 +368,10 @@ class RDoc::Markup
flag = nil
case prefix
when /^\[/
flag = ListBase::LABELED
flag = :LABELED
prefix = prefix[1, prefix.length-2]
when /:$/
flag = ListBase::NOTE
flag = :NOTE
prefix.chop!
else raise "Invalid List Type: #{self.inspect}"
end
@ -403,7 +402,7 @@ class RDoc::Markup
end
end
line.stamp(Line::LIST, level+1, prefix, flag)
line.stamp :LIST, level+1, prefix, flag
text[margin, prefix_length] = " " * prefix_length
assign_types_to_lines(offset, level + 1)
return true
@ -431,12 +430,12 @@ class RDoc::Markup
else
group = block.fragment_for(line)
block.add(group)
if line.type == Line::LIST
wantedType = Line::PARAGRAPH
if line.type == :LIST
wantedType = :PARAGRAPH
else
wantedType = line.type
end
wantedLevel = line.type == Line::HEADING ? line.param : line.level
wantedLevel = line.type == :HEADING ? line.param : line.level
end
end

58
lib/rdoc/markup/fragments.rb
View file

@ -11,6 +11,22 @@ class RDoc::Markup
attr_reader :level, :param, :txt
attr_accessor :type
######
# This is a simple factory system that lets us associate fragement
# types (a string) with a subclass of fragment
TYPE_MAP = {}
def self.type_name(name)
TYPE_MAP[name] = self
end
def self.for(line)
klass = TYPE_MAP[line.type] ||
raise("Unknown line type: '#{line.type.inspect}:' '#{line.text}'")
return klass.new(line.level, line.param, line.flag, line.text)
end
def initialize(level, param, type, txt)
@level = level
@param = param
@ -28,21 +44,6 @@ class RDoc::Markup
"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
##
@ -50,15 +51,15 @@ class RDoc::Markup
# newlines when we're created, and have them put back on output.
class Paragraph < Fragment
type_name Line::PARAGRAPH
type_name :PARAGRAPH
end
class BlankLine < Paragraph
type_name Line::BLANK
type_name :BLANK
end
class Heading < Paragraph
type_name Line::HEADING
type_name :HEADING
def head_level
@param.to_i
@ -69,17 +70,18 @@ class RDoc::Markup
# 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
LIST_TYPES = [
:BULLET,
:NUMBER,
:UPPERALPHA,
:LOWERALPHA,
:LABELED,
:NOTE,
]
end
class ListItem < ListBase
type_name Line::LIST
type_name :LIST
# def label
# am = AttributeManager.new(@param)
@ -103,7 +105,7 @@ class RDoc::Markup
# Verbatim code contains lines that don't get wrapped.
class Verbatim < Fragment
type_name Line::VERBATIM
type_name :VERBATIM
def add_text(txt)
@txt << txt.chomp << "\n"
@ -115,7 +117,7 @@ class RDoc::Markup
# A horizontal rule
class Rule < Fragment
type_name Line::RULE
type_name :RULE
end
##

16
lib/rdoc/markup/lines.rb
View file

@ -8,12 +8,14 @@ class RDoc::Markup
class Line
INFINITY = 9999
BLANK = :BLANK
HEADING = :HEADING
LIST = :LIST
RULE = :RULE
PARAGRAPH = :PARAGRAPH
VERBATIM = :VERBATIM
LINE_TYPES = [
:BLANK,
:HEADING,
:LIST,
:PARAGRAPH,
:RULE,
:VERBATIM,
]
# line type
attr_accessor :type
@ -132,7 +134,7 @@ class RDoc::Markup
def normalize
margin = @lines.collect{|l| l.leading_spaces}.min
margin = 0 if margin == Line::INFINITY
margin = 0 if margin == :INFINITY
@lines.each {|line| line.strip_leading(margin) } if margin > 0
end

12
lib/rdoc/markup/to_flow.rb
View file

@ -24,12 +24,12 @@ class RDoc::Markup
class ToFlow
LIST_TYPE_TO_HTML = {
RDoc::Markup::ListBase::BULLET => [ "<ul>", "</ul>" ],
RDoc::Markup::ListBase::NUMBER => [ "<ol>", "</ol>" ],
RDoc::Markup::ListBase::UPPERALPHA => [ "<ol>", "</ol>" ],
RDoc::Markup::ListBase::LOWERALPHA => [ "<ol>", "</ol>" ],
RDoc::Markup::ListBase::LABELED => [ "<dl>", "</dl>" ],
RDoc::Markup::ListBase::NOTE => [ "<table>", "</table>" ],
:BULLET => [ "<ul>", "</ul>" ],
:NUMBER => [ "<ol>", "</ol>" ],
:UPPERALPHA => [ "<ol>", "</ol>" ],
:LOWERALPHA => [ "<ol>", "</ol>" ],
:LABELED => [ "<dl>", "</dl>" ],
:NOTE => [ "<table>", "</table>" ],
}
InlineTag = Struct.new(:bit, :on, :off)

30
lib/rdoc/markup/to_html.rb
View file

@ -6,12 +6,12 @@ require 'cgi'
class RDoc::Markup::ToHtml
LIST_TYPE_TO_HTML = {
RDoc::Markup::ListBase::BULLET => [ "<ul>", "</ul>" ],
RDoc::Markup::ListBase::NUMBER => [ "<ol>", "</ol>" ],
RDoc::Markup::ListBase::UPPERALPHA => [ "<ol>", "</ol>" ],
RDoc::Markup::ListBase::LOWERALPHA => [ "<ol>", "</ol>" ],
RDoc::Markup::ListBase::LABELED => [ "<dl>", "</dl>" ],
RDoc::Markup::ListBase::NOTE => [ "<table>", "</table>" ],
:BULLET => [ "<ul>", "</ul>" ],
:NUMBER => [ "<ol>", "</ol>" ],
:UPPERALPHA => [ "<ol>", "</ol>" ],
:LOWERALPHA => [ "<ol>", "</ol>" ],
:LABELED => [ "<dl>", "</dl>" ],
:NOTE => [ "<table>", "</table>" ],
}
InlineTag = Struct.new(:bit, :on, :off)
@ -241,22 +241,22 @@ class RDoc::Markup::ToHtml
def list_item_start(am, fragment)
case fragment.type
when RDoc::Markup::ListBase::BULLET, RDoc::Markup::ListBase::NUMBER then
when :BULLET, :NUMBER then
annotate("<li>")
when RDoc::Markup::ListBase::UPPERALPHA then
when :UPPERALPHA then
annotate("<li type=\"A\">")
when RDoc::Markup::ListBase::LOWERALPHA then
when :LOWERALPHA then
annotate("<li type=\"a\">")
when RDoc::Markup::ListBase::LABELED then
when :LABELED then
annotate("<dt>") +
convert_flow(am.flow(fragment.param)) +
annotate("</dt>") +
annotate("<dd>")
when RDoc::Markup::ListBase::NOTE then
when :NOTE then
annotate("<tr>") +
annotate("<td valign=\"top\">") +
convert_flow(am.flow(fragment.param)) +
@ -269,13 +269,11 @@ class RDoc::Markup::ToHtml
def list_end_for(fragment_type)
case fragment_type
when RDoc::Markup::ListBase::BULLET, RDoc::Markup::ListBase::NUMBER,
RDoc::Markup::ListBase::UPPERALPHA,
RDoc::Markup::ListBase::LOWERALPHA then
when :BULLET, :NUMBER, :UPPERALPHA, :LOWERALPHA then
"</li>"
when RDoc::Markup::ListBase::LABELED then
when :LABELED then
"</dd>"
when RDoc::Markup::ListBase::NOTE then
when :NOTE then
"</td></tr>"
else
raise "Invalid list type"

28
lib/rdoc/markup/to_latex.rb
View file

@ -29,12 +29,12 @@ class RDoc::Markup::ToLaTeX
end
LIST_TYPE_TO_LATEX = {
RDoc::Markup::ListBase::BULLET => [ l("\\begin{itemize}"), l("\\end{itemize}") ],
RDoc::Markup::ListBase::NUMBER => [ l("\\begin{enumerate}"), l("\\end{enumerate}"), "\\arabic" ],
RDoc::Markup::ListBase::UPPERALPHA => [ l("\\begin{enumerate}"), l("\\end{enumerate}"), "\\Alph" ],
RDoc::Markup::ListBase::LOWERALPHA => [ l("\\begin{enumerate}"), l("\\end{enumerate}"), "\\alph" ],
RDoc::Markup::ListBase::LABELED => [ l("\\begin{description}"), l("\\end{description}") ],
RDoc::Markup::ListBase::NOTE => [
:BULLET => [ l("\\begin{itemize}"), l("\\end{itemize}") ],
:NUMBER => [ l("\\begin{enumerate}"), l("\\end{enumerate}"), "\\arabic" ],
:UPPERALPHA => [ l("\\begin{enumerate}"), l("\\end{enumerate}"), "\\Alph" ],
:LOWERALPHA => [ l("\\begin{enumerate}"), l("\\end{enumerate}"), "\\alph" ],
:LABELED => [ l("\\begin{description}"), l("\\end{description}") ],
:NOTE => [
l("\\begin{tabularx}{\\linewidth}{@{} l X @{}}"),
l("\\end{tabularx}") ],
}
@ -299,15 +299,13 @@ class RDoc::Markup::ToLaTeX
def list_item_start(am, fragment)
case fragment.type
when RDoc::Markup::ListBase::BULLET, RDoc::Markup::ListBase::NUMBER,
RDoc::Markup::ListBase::UPPERALPHA,
RDoc::Markup::ListBase::LOWERALPHA then
when :BULLET, :NUMBER, :UPPERALPHA, :LOWERALPHA then
"\\item "
when RDoc::Markup::ListBase::LABELED then
when :LABELED then
"\\item[" + convert_flow(am.flow(fragment.param)) + "] "
when RDoc::Markup::ListBase::NOTE then
when :NOTE then
convert_flow(am.flow(fragment.param)) + " & "
else
raise "Invalid list type"
@ -316,13 +314,9 @@ class RDoc::Markup::ToLaTeX
def list_end_for(fragment_type)
case fragment_type
when RDoc::Markup::ListBase::BULLET,
RDoc::Markup::ListBase::NUMBER,
RDoc::Markup::ListBase::UPPERALPHA,
RDoc::Markup::ListBase::LOWERALPHA,
RDoc::Markup::ListBase::LABELED then
when :BULLET, :NUMBER, :UPPERALPHA, :LOWERALPHA, :LABELED then
""
when RDoc::Markup::ListBase::NOTE
when :NOTE
"\\\\\n"
else
raise "Invalid list type"

49
lib/rdoc/markup/to_test.rb Normal file
View file

@ -0,0 +1,49 @@
require 'rdoc/markup'
##
# This Markup outputter is used for testing purposes.
class RDoc::Markup::ToTest
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

2
lib/rdoc/ri/display.rb
View file

@ -34,7 +34,7 @@ class RDoc::RI::DefaultDisplay
def initialize(formatter, width, use_stdout)
@use_stdout = use_stdout
@formatter = formatter.new width, " "
@formatter = formatter.new $stdout, width, " "
end
def display_method_info(method)

217
lib/rdoc/ri/formatter.rb
View file

@ -1,27 +1,49 @@
require 'rdoc/ri'
require 'rdoc/markup'
class RDoc::RI::Formatter
attr_reader :indent
def initialize(width, indent)
@width = width
@indent = indent
FORMATTERS = { }
def self.for(name)
FORMATTERS[name.downcase]
end
def self.list
FORMATTERS.keys.sort.join ", "
end
def initialize(output, width, indent)
@output = output
@width = width
@indent = indent
end
def draw_line(label=nil)
len = @width
len -= (label.size+1) if label
print "-"*len
if label
print(" ")
bold_print(label)
len -= (label.size + 1) if label
if len > 0 then
@output.print '-' * len
if label
@output.print ' '
bold_print label
end
@output.puts
else
@output.print '-' * @width
@output.puts
@output.puts label
end
puts
end
def wrap(txt, prefix=@indent, linelen=@width)
def wrap(txt, prefix=@indent, linelen=@width)
return unless txt && !txt.empty?
work = conv_markup(txt)
textLen = linelen - prefix.length
patt = Regexp.new("^(.{0,#{textLen}})[ \n]")
@ -38,11 +60,11 @@ class RDoc::RI::Formatter
end
end
res << work if work.length.nonzero?
puts(prefix + res.join("\n" + next_prefix))
@output.puts(prefix + res.join("\n" + next_prefix))
end
def blankline
puts
@output.puts
end
##
@ -53,11 +75,11 @@ class RDoc::RI::Formatter
end
def bold_print(txt)
print txt
@output.print txt
end
def raw_print_line(txt)
puts txt
@output.puts txt
end
##
@ -69,7 +91,6 @@ class RDoc::RI::Formatter
gsub(/&lt;/, '<').
gsub(/&quot;/, '"').
gsub(/&amp;/, '&')
end
##
@ -78,25 +99,22 @@ class RDoc::RI::Formatter
def conv_markup(txt)
txt.
gsub(%r{<tt>(.*?)</tt>}) { "+#$1+" } .
gsub(%r{<code>(.*?)</code>}) { "+#$1+" } .
gsub(%r{<b>(.*?)</b>}) { "*#$1*" } .
gsub(%r{<em>(.*?)</em>}) { "_#$1_" }
gsub(%r{<code>(.*?)</code>}) { "+#$1+" } .
gsub(%r{<b>(.*?)</b>}) { "*#$1*" } .
gsub(%r{<em>(.*?)</em>}) { "_#$1_" }
end
def display_list(list)
case list.type
when RDoc::Markup::ListBase::BULLET
when :BULLET
prefixer = proc { |ignored| @indent + "* " }
when RDoc::Markup::ListBase::NUMBER,
RDoc::Markup::ListBase::UPPERALPHA,
RDoc::Markup::ListBase::LOWERALPHA
when :NUMBER, :UPPERALPHA, :LOWERALPHA then
start = case list.type
when RDoc::Markup::ListBase::NUMBER then 1
when RDoc::Markup::ListBase::UPPERALPHA then 'A'
when RDoc::Markup::ListBase::LOWERALPHA then 'a'
when :NUMBER then 1
when :UPPERALPHA then 'A'
when :LOWERALPHA then 'a'
end
prefixer = proc do |ignored|
res = @indent + "#{start}.".ljust(4)
@ -104,12 +122,12 @@ class RDoc::RI::Formatter
res
end
when RDoc::Markup::ListBase::LABELED
when :LABELED then
prefixer = proc do |li|
li.label
end
when RDoc::Markup::ListBase::NOTE
when :NOTE then
longest = 0
list.contents.each do |item|
if item.kind_of?(RDoc::Markup::Flow::LI) && item.label.length > longest
@ -122,8 +140,7 @@ class RDoc::RI::Formatter
end
else
fail "unknown list type"
raise ArgumentError, "unknown list type #{list.type}"
end
list.contents.each do |item|
@ -161,7 +178,7 @@ class RDoc::RI::Formatter
def display_verbatim_flow_item(item, prefix=@indent)
item.body.split(/\n/).each do |line|
print @indent, conv_html(line), "\n"
@output.print @indent, conv_html(line), "\n"
end
blankline
end
@ -171,19 +188,19 @@ class RDoc::RI::Formatter
case level
when 1
ul = "=" * text.length
puts
puts text.upcase
puts ul
@output.puts
@output.puts text.upcase
@output.puts ul
# puts
when 2
ul = "-" * text.length
puts
puts text
puts ul
@output.puts
@output.puts text
@output.puts ul
# puts
else
print indent, text, "\n"
@output.print indent, text, "\n"
end
end
@ -274,11 +291,11 @@ class RDoc::RI::AttributeFormatter < RDoc::RI::Formatter
end
##
# Overrides base class. Looks for <tt>...</tt> etc sequences
# and generates an array of AttrChars. This array is then used
# as the basis for the split
# Overrides base class. Looks for <tt>...</tt> etc sequences and generates
# an array of AttrChars. This array is then used as the basis for the
# split.
def wrap(txt, prefix=@indent, linelen=@width)
def wrap(txt, prefix=@indent, linelen=@width)
return unless txt && !txt.empty?
txt = add_attributes_to(txt)
@ -303,15 +320,15 @@ class RDoc::RI::AttributeFormatter < RDoc::RI::Formatter
protected
def write_attribute_text(prefix, line)
print prefix
@output.print prefix
line.each do |achar|
print achar.char
@output.print achar.char
end
puts
@output.puts
end
def bold_print(txt)
print txt
@output.print txt
end
private
@ -342,18 +359,18 @@ class RDoc::RI::OverstrikeFormatter < RDoc::RI::AttributeFormatter
BS = "\C-h"
def write_attribute_text(prefix, line)
print prefix
@output.print prefix
line.each do |achar|
attr = achar.attr
if (attr & (ITALIC+CODE)) != 0
print "_", BS
@output.print "_", BS
end
if (attr & BOLD) != 0
print achar.char, BS
@output.print achar.char, BS
end
print achar.char
@output.print achar.char
end
puts
@output.puts
end
##
@ -361,7 +378,7 @@ class RDoc::RI::OverstrikeFormatter < RDoc::RI::AttributeFormatter
def bold_print(text)
text.split(//).each do |ch|
print ch, BS, ch
@output.print ch, BS, ch
end
end
@ -374,12 +391,12 @@ end
class RDoc::RI::AnsiFormatter < RDoc::RI::AttributeFormatter
def initialize(*args)
print "\033[0m"
super
@output.print "\033[0m"
end
def write_attribute_text(prefix, line)
print prefix
@output.print prefix
curr_attr = 0
line.each do |achar|
attr = achar.attr
@ -387,14 +404,14 @@ class RDoc::RI::AnsiFormatter < RDoc::RI::AttributeFormatter
update_attributes(achar.attr)
curr_attr = achar.attr
end
print achar.char
@output.print achar.char
end
update_attributes(0) unless curr_attr.zero?
puts
@output.puts
end
def bold_print(txt)
print "\033[1m#{txt}\033[m"
@output.print "\033[1m#{txt}\033[m"
end
HEADINGS = {
@ -406,10 +423,10 @@ class RDoc::RI::AnsiFormatter < RDoc::RI::AttributeFormatter
def display_heading(text, level, indent)
level = 3 if level > 3
heading = HEADINGS[level]
print indent
print heading[0]
print strip_attributes(text)
puts heading[1]
@output.print indent
@output.print heading[0]
@output.print strip_attributes(text)
@output.puts heading[1]
end
private
@ -427,7 +444,7 @@ class RDoc::RI::AnsiFormatter < RDoc::RI::AttributeFormatter
str << ATTR_MAP[quality]
end
end
print str, "m"
@output.print str, "m"
end
end
@ -445,7 +462,7 @@ class RDoc::RI::HtmlFormatter < RDoc::RI::AttributeFormatter
update_attributes(curr_attr, achar.attr)
curr_attr = achar.attr
end
print(escape(achar.char))
@output.print(escape(achar.char))
end
update_attributes(curr_attr, 0) unless curr_attr.zero?
end
@ -454,7 +471,7 @@ class RDoc::RI::HtmlFormatter < RDoc::RI::AttributeFormatter
if label != nil
bold_print(label)
end
puts("<hr>")
@output.puts("<hr>")
end
def bold_print(txt)
@ -462,38 +479,36 @@ class RDoc::RI::HtmlFormatter < RDoc::RI::AttributeFormatter
end
def blankline()
puts("<p>")
@output.puts("<p>")
end
def break_to_newline
puts("<br>")
@output.puts("<br>")
end
def display_heading(text, level, indent)
level = 4 if level > 4
tag("h#{level}") { text }
puts
@output.puts
end
def display_list(list)
case list.type
when RDoc::Markup::ListBase::BULLET
when :BULLET then
list_type = "ul"
prefixer = proc { |ignored| "<li>" }
when RDoc::Markup::ListBase::NUMBER,
RDoc::Markup::ListBase::UPPERALPHA,
RDoc::Markup::ListBase::LOWERALPHA
when :NUMBER, :UPPERALPHA, :LOWERALPHA then
list_type = "ol"
prefixer = proc { |ignored| "<li>" }
when RDoc::Markup::ListBase::LABELED
when :LABELED then
list_type = "dl"
prefixer = proc do |li|
"<dt><b>" + escape(li.label) + "</b><dd>"
end
when RDoc::Markup::ListBase::NOTE
when :NOTE then
list_type = "table"
prefixer = proc do |li|
%{<tr valign="top"><td>#{li.label.gsub(/ /, '&nbsp;')}</td><td>}
@ -502,25 +517,25 @@ class RDoc::RI::HtmlFormatter < RDoc::RI::AttributeFormatter
fail "unknown list type"
end
print "<#{list_type}>"
@output.print "<#{list_type}>"
list.contents.each do |item|
if item.kind_of? RDoc::Markup::Flow::LI
prefix = prefixer.call(item)
print prefix
@output.print prefix
display_flow_item(item, prefix)
else
display_flow_item(item)
end
end
print "</#{list_type}>"
@output.print "</#{list_type}>"
end
def display_verbatim_flow_item(item, prefix=@indent)
print("<pre>")
@output.print("<pre>")
item.body.split(/\n/).each do |line|
puts conv_html(line)
@output.puts conv_html(line)
end
puts("</pre>")
@output.puts("</pre>")
end
private
@ -547,13 +562,13 @@ class RDoc::RI::HtmlFormatter < RDoc::RI::AttributeFormatter
str << "<" << ATTR_MAP[quality]
end
end
print str
@output.print str
end
def tag(code)
print("<#{code}>")
print(yield)
print("</#{code}>")
@output.print("<#{code}>")
@output.print(yield)
@output.print("</#{code}>")
end
def escape(str)
@ -584,7 +599,7 @@ class RDoc::RI::SimpleFormatter < RDoc::RI::Formatter
def draw_line(label=nil)
unless label.nil? then
bold_print(label)
puts
@output.puts
end
end
@ -595,36 +610,18 @@ class RDoc::RI::SimpleFormatter < RDoc::RI::Formatter
text = strip_attributes(text)
case level
when 1
puts "= " + text.upcase
@output.puts "= " + text.upcase
when 2
puts "-- " + text
@output.puts "-- " + text
else
print indent, text, "\n"
@output.print indent, text, "\n"
end
end
end
##
# Finally, fill in the list of known formatters
class RDoc::RI::Formatter
FORMATTERS = {
"plain" => RDoc::RI::Formatter,
"simple" => RDoc::RI::SimpleFormatter,
"bs" => RDoc::RI::OverstrikeFormatter,
"ansi" => RDoc::RI::AnsiFormatter,
"html" => RDoc::RI::HtmlFormatter,
}
def self.list
FORMATTERS.keys.sort.join(", ")
end
def self.for(name)
FORMATTERS[name.downcase]
end
end
RDoc::RI::Formatter::FORMATTERS['plain'] = RDoc::RI::Formatter
RDoc::RI::Formatter::FORMATTERS['simple'] = RDoc::RI::SimpleFormatter
RDoc::RI::Formatter::FORMATTERS['bs'] = RDoc::RI::OverstrikeFormatter
RDoc::RI::Formatter::FORMATTERS['ansi'] = RDoc::RI::AnsiFormatter
RDoc::RI::Formatter::FORMATTERS['html'] = RDoc::RI::HtmlFormatter

2
test/rdoc/parsers/test_parse_c.rb → test/rdoc/test_rdoc_c_parser.rb
View file

@ -17,7 +17,7 @@ class TestRdocC_Parser < Test::Unit::TestCase
@top_level = RDoc::TopLevel.new filename
@fn = filename
@options = Options.instance
@options = RDoc::Options.new Hash.new
@stats = RDoc::Stats.new
@progress = StringIO.new

61
test/rdoc/test_simple_markup.rb → test/rdoc/test_rdoc_markup.rb
View file

@ -1,62 +1,19 @@
require 'test/unit'
require 'rdoc/markup/simple_markup'
require 'rdoc/markup'
require 'rdoc/markup/to_test'
class TestSimpleMarkup < 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
class TestRDocMarkup < Test::Unit::TestCase
def basic_conv(str)
sm = SM::SimpleMarkup.new
mock = MockOutput.new
sm = RDoc::Markup.new
mock = RDoc::Markup::ToTest.new
sm.convert(str, mock)
sm.content
end
def line_groups(str, expected)
p = SM::SimpleMarkup.new
mock = MockOutput.new
p = RDoc::Markup.new
mock = RDoc::Markup::ToTest.new
block = p.convert(str, mock)
@ -72,8 +29,8 @@ class TestSimpleMarkup < Test::Unit::TestCase
end
def line_types(str, expected)
p = SM::SimpleMarkup.new
mock = MockOutput.new
p = RDoc::Markup.new
mock = RDoc::Markup::ToTest.new
p.convert(str, mock)
assert_equal(expected, p.get_line_types.map{|type| type.to_s[0,1]}.join(''))
end

12
test/rdoc/test_simple_markup_attribute_manager.rb → test/rdoc/test_rdoc_markup_attribute_manager.rb
View file

@ -1,10 +1,10 @@
require "test/unit"
require "rdoc/markup/simple_markup/inline"
require "rdoc/markup/inline"
class TestSimpleMarkupAttributeManager < Test::Unit::TestCase
class TestRDocMarkupAttributeManager < Test::Unit::TestCase
def setup
@am = SM::AttributeManager.new
@am = RDoc::Markup::AttributeManager.new
@bold_on = @am.changed_attribute_by_name([], [:BOLD])
@bold_off = @am.changed_attribute_by_name([:BOLD], [])
@ -28,11 +28,11 @@ class TestSimpleMarkupAttributeManager < Test::Unit::TestCase
end
def crossref(text)
crossref_bitmap = SM::Attribute.bitmap_for(:_SPECIAL_) |
SM::Attribute.bitmap_for(:CROSSREF)
crossref_bitmap = RDoc::Markup::Attribute.bitmap_for(:_SPECIAL_) |
RDoc::Markup::Attribute.bitmap_for(:CROSSREF)
[ @am.changed_attribute_by_name([], [:CROSSREF] | [:_SPECIAL_]),
SM::Special.new(crossref_bitmap, text),
RDoc::Markup::Special.new(crossref_bitmap, text),
@am.changed_attribute_by_name([:CROSSREF] | [:_SPECIAL_], [])
]
end

42
test/rdoc/test_rdoc_ri_attribute_formatter.rb Normal file
View file

@ -0,0 +1,42 @@
require 'stringio'
require 'test/unit'
require 'rdoc/ri/formatter'
class TestRDocRIAttributeFormatter < Test::Unit::TestCase
def setup
@output = StringIO.new
@width = 78
@indent = ' '
@f = RDoc::RI::AttributeFormatter.new @output, @width, @indent
end
def test_wrap_empty
@f.wrap ''
assert_equal '', @output.string
end
def test_wrap_long
@f.wrap 'a ' * (@width / 2)
assert_equal " a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a \n a \n",
@output.string
end
def test_wrap_markup
@f.wrap 'a <tt>b</tt> c'
assert_equal " a b c\n", @output.string
end
def test_wrap_nil
@f.wrap nil
assert_equal '', @output.string
end
def test_wrap_short
@f.wrap 'a b c'
assert_equal " a b c\n", @output.string
end
end

124
test/rdoc/test_rdoc_ri_formatter.rb Normal file
View file

@ -0,0 +1,124 @@
require 'stringio'
require 'test/unit'
require 'rdoc/ri/formatter'
require 'rdoc/markup/to_flow'
class TestRDocRIFormatter < Test::Unit::TestCase
def setup
@output = StringIO.new
@width = 78
@indent = ' '
@f = RDoc::RI::Formatter.new @output, @width, @indent
@markup = RDoc::Markup.new
@flow = RDoc::Markup::ToFlow.new
end
def test_blankline
@f.blankline
assert_equal "\n", @output.string
end
def test_bold_print
@f.bold_print 'a b c'
assert_equal 'a b c', @output.string
end
def test_break_to_newline
@f.break_to_newline
assert_equal '', @output.string
end
def test_conv_html
assert_equal '> < " &', @f.conv_html('&gt; &lt; &quot; &amp;')
end
def test_conv_markup
text = '<tt>a</tt> <code>b</code> <b>c</b> <em>d</em>'
expected = '+a+ +b+ *c* _d_'
assert_equal expected, @f.conv_markup(text)
end
def test_display_list_bullet
list = util_convert('* a b c').first
@f.display_list list
assert_equal " * a b c\n\n", @output.string
end
def test_display_list_unknown
list = util_convert('* a b c').first
list.instance_variable_set :@type, :UNKNOWN
e = assert_raise ArgumentError do
@f.display_list list
end
assert_equal 'unknown list type UNKNOWN', e.message
end
def test_draw_line
@f.draw_line
expected = '-' * @width + "\n"
assert_equal expected, @output.string
end
def test_draw_line_label
@f.draw_line 'label'
expected = '-' * (@width - 6) + " label\n"
assert_equal expected, @output.string
end
def test_draw_line_label_long
@f.draw_line 'a' * @width
expected = '-' * @width + "\n" + ('a' * @width) + "\n"
assert_equal expected, @output.string
end
def test_raw_print_line
@f.raw_print_line 'a b c'
assert_equal "a b c\n", @output.string
end
def test_wrap_empty
@f.wrap ''
assert_equal '', @output.string
end
def test_wrap_long
@f.wrap 'a ' * (@width / 2)
assert_equal " a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a\n a \n",
@output.string
end
def test_wrap_markup
@f.wrap 'a <tt>b</tt> c'
assert_equal " a +b+ c\n", @output.string
end
def test_wrap_nil
@f.wrap nil
assert_equal '', @output.string
end
def test_wrap_short
@f.wrap 'a b c'
assert_equal " a b c\n", @output.string
end
def util_convert(text)
@markup.convert text, @flow
end
end